claude-usage-limits 1.40.3 → 1.40.5

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "usage-limits",
   "displayName": "Usage Limits",
-  "version": "1.40.3",
+  "version": "1.40.5",
   "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.3",
+  "version": "1.40.5",
   "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

@@ -393,20 +393,20 @@ 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.
+If the wall offers it, /low-priority can carry 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 only the user can type, and type again to stop: you cannot run a slash
+command, and nothing here can switch it on.
 ```
 
 **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
+hook and no file, and one user has reported it burning through almost a week of
+usage in a couple of hours (anthropics/claude-code#92544). 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.
 
@@ -442,13 +442,19 @@ 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.
+**`/limit-reset`** is one command behind two different server flags, and the
+brief words each in its own copy's terms. `tengu_nifty_lemur` is the
+once-a-week reset of the 5-hour session limit ("uses weekly limit · 1/week",
+"your weekly limit still applies"); `tengu_cedar_ember` is a counted grant with
+a use-by date that "refills your limits". The account this was built on carries
+`tengu_nifty_lemur` enabled and no `tengu_cedar_ember`. When the budget is tight
+and the 5-hour window is the wall, the brief names the weekly reset, says the
+work it unlocks still counts toward the weekly, and says only the user can type
+it; at a weekly wall it says nothing, because resetting the 5-hour limit cannot
+help there. It never reports whether this week's reset is used or how many
+grants are left — both come from a live endpoint and appear in no file a hook
+can read. A flag counts only when it is a plain object with `enabled: true`,
+the way the CLI reads it.
 
 **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`
@@ -1114,7 +1120,23 @@ There are two separate things people mean by "change the model":
 
 `claude-usage-limits mode --baseline` shows both side by side. The budget line
 now says the tier as well, and where the reading came from, because the number
-that decides what a turn costs was the one number the line never printed.
+that decides what a turn costs was the one number the line never printed. It
+names the version, not only the family (`opus 5.5/xhigh`, not `opus/xhigh`),
+read from the newest assistant message in the session's transcript: a settings
+alias such as `opus` cannot say which Opus answered.
+
+When the model running is an older release of a family that has a newer one at
+a lower price - Opus 5 or 4.8 against Opus 5.5 ($4/$20, cache reads $0.20
+against $0.50), Fable 5 against Fable 5.1 (reads $0.25 against $1) - the brief
+says so once per session, with the prices and how many turns the one-off cache
+rebuild takes to repay. In Claude Code it offers `/model <id>`, which switches
+the session and saves the model as the default for new sessions; elsewhere it
+offers the host's own model setting and names no slash command. A relay whose
+own `model` is pinned to the older release is named too, since a wake starts
+with that `--model` whatever the session switched to. Releases on
+either side of the 4.7 tokenizer change are not compared, because a price per
+token is not like for like across it. `mode --no-advice` mutes this with the
+rest of the advice.
 
 What Claude can genuinely move, stated without embroidery: the model on an
 `Agent` call, and the model and effort inside a `Workflow` script. Its own

package/commands/relay.md

@@ -29,6 +29,9 @@ The rest:
   (or whichever mode you want) as well: a resume does **not** inherit the
   session's permission mode, so without one it will sit waiting for an
   approval nobody is there to give. `show off` makes it a headless run instead.
+- `model <id>` - the `--model` a resumed run starts with; `model` alone goes
+  back to the default. It is separate from `/model` in the session, so a wake
+  pinned to an older model stays on it until this is changed.
 - `voice on|off` - carry how you write in the hand-off, so the resumed session
   answers in your voice without being reminded. On by default.
 - `bugcheck on|always|off` - the hand-off asks for two bug passes before anything

package/package.json

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

@@ -625,10 +625,11 @@ 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.
+The same applies to `/limit-reset`, the manual reset: only the user can type
+it. The line names it only when the account's flags say it is set up. The
+once-a-week kind resets the 5-hour limit and its work still counts toward the
+weekly, so it is named only at a 5-hour wall; whether this week's is already
+used, and how many of the counted kind 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

package/skills/usage-limits/references/how-it-works.md

@@ -256,8 +256,9 @@ A bracketed suffix on a model id (`claude-sonnet-5[1m]`) is stripped before
 the lookup: it marks a context-window variant of the same model, not a new
 one. Cache reads price at a tenth of the input rate unless a row carries a
 `cacheRead` figure of its own - Fable and Mythos 5.1 price reads outright at
-$0.25 per million, far under the tenth rule, and reads are the dominant input
-in exactly the long sessions where the difference matters.
+$0.25 per million (0.025x input) and Opus 5.5 at $0.20 (0.05x its $4 input),
+all under the tenth rule, and reads are the dominant input in exactly the long
+sessions where the difference matters.
 
 Until someone does, a model this table has not seen is priced at the average of
 the family its name contains: an unreleased `claude-opus-5-2` is charged at the

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

@@ -160,7 +160,7 @@ function readSaid() {
   }
 }
 function keepSaidFor(key) {
-  return /#(standing|cachemiss|stale|relaylast)$/.test(key) ? 24 * 60 * 60 * 1000 : 60 * 60 * 1000;
+  return /#(standing|cachemiss|stale|relaylast|newer)$/.test(key) ? 24 * 60 * 60 * 1000 : 60 * 60 * 1000;
 }
 
 // A plugin update takes effect when Claude Code restarts, so a session that
@@ -202,6 +202,30 @@ function staleVersionFor(sessionId, now, dir) {
   return 'usage-limits ' + installed + ' is installed but this session still runs ' + running +
     ', because a plugin update applies at the next start; a relay or cap set here follows the older rules until then.';
 }
+// A newer model of the same family at a lower price, said once a session.
+// Once is the rule every recommendation here keeps: the fact does not change
+// from prompt to prompt, and repeating it would be the plugin charging for its
+// own presence. Keyed on the pair, so a session that moves to a different model
+// with its own newer sibling hears about that one.
+function newerModelFor(sessionId, advice, now) {
+  if (!advice || !advice.text) return null;
+  const at = Number.isFinite(now) ? now : Date.now();
+  const key = String(sessionId || '_') + '#newer';
+  const all = readSaid();
+  const entry = all[key];
+  if (entry && entry.seen === advice.id && Number.isFinite(entry.at) && at - entry.at < keepSaidFor(key)) return null;
+  all[key] = { at, seen: advice.id };
+  writeSaid(all, at);
+  return advice.text;
+}
+// The model the relay resumes with, when one is set: wake.js passes it as --model.
+function relayModelNow() {
+  try {
+    return relay.settings(relay.read()).model || null;
+  } catch (err) {
+    return null;
+  }
+}
 // How the last relay ended is news once. It used to ride along for six hours
 // after any relay ended, on every prompt of every session: on 2026-09-22 a wake
 // lost at 5:53 AM was repeated in two sessions' briefs all afternoon, about
@@ -784,6 +808,7 @@ function briefText(input) {
   if (parts.tier) sentences.push(parts.tier);
   // Once per session, and only when the installed version is not this one.
   if (parts.staleVersion) sentences.push(parts.staleVersion);
+  if (parts.newerModel) sentences.push(parts.newerModel);
   const bounded = mode.boundsNote(bounds);
   if (bounded) sentences.push(bounded);
   if (parts.planChanged) {
@@ -1028,53 +1053,99 @@ function briefText(input) {
   // 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') {
+  // The acknowledged sentence describes the SWAP, so it may only be said when
+  // the swap really happened. wallFeatures refuses to swap unless there is a
+  // weekly window with a live percentage and a known reset, and this branch
+  // used to fire on the acknowledgement alone - so on an account with no
+  // readable weekly the brief said "binding window is 5-hour 99% used" in one
+  // clause and "the figures above are the weekly" in the next. A line that
+  // contradicts the numbers printed beside it is worse than no line: it tells
+  // the model to ignore a wall that is still there.
+  if (lp && lp.state === 'acknowledged' && lp.weeklyBinding) {
     lowPrioritySentence = (
-      'You have said /low-priority is on, so the brake is the weekly window and not the 5-hour one: ' +
+      'The user has 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 ' +
+        'capacity. Whether it is still on cannot be read from here, so if the user says it has ended, ' +
+        'record that 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.state === 'acknowledged') {
+    // Acknowledged, but there is no weekly reading to brake on, so the figures
+    // above are still the window they say they are and the wall is still real.
+    lowPrioritySentence = (
+      'The user has said /low-priority is on, which spends the weekly limit instead of stopping at the ' +
+        '5-hour one - but there is no usable weekly reading here to brake on, so the figures above are ' +
+        'the window named beside them and that window is still the one to plan against. /usage (the ' +
+        'user types it) refreshes the account snapshot; until it has a weekly, treat the limit above as real.'
+    );
   } 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 ' +
+      'If the wall offers it, /low-priority can carry 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.'
+        'capacity - the wait and its ceiling are set by the server per request. It is a toggle only ' +
+        'the user can type, and type again to stop: you cannot run a slash command, and nothing here ' +
+        'can switch it on. Tell the user in one line that it is there; if the user says 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.'
+        'allowance as well, which one user has reported burning through almost a week of usage in a ' +
+        'couple of hours. The choice is the user\'s, and only the user can type it: say in one line ' +
+        'that this plugin advises against it 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.
+  // A manual reset behind /limit-reset, when this account holds one.
+  //
+  // Two server flags sit behind the one command and they are different offers,
+  // so each is worded in its own copy's terms and nothing is borrowed across
+  // (lowpri.sessionReset has the bundle strings):
+  //
+  //   'weekly' (tengu_nifty_lemur, which this account has): resets the 5-hour
+  //   session limit, once a week, and the work still counts toward the weekly.
+  //   So it only helps when the 5-hour window is the wall - said at a weekly
+  //   wall it would be advice that cannot work - and the first build, reading
+  //   only the other flag, never said it at all.
   //
-  // /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')) {
+  //   'grant' (tengu_cedar_ember): a counted reset with a use-by date that
+  //   "refills your limits". Its copy does not say it spends the weekly, and it
+  //   has an early-use path, so neither "once a week" nor "only at a limit" is
+  //   claimed for it.
+  //
+  // Neither is counted: whether this week's reset is already used, and how
+  // many grants are left, are served by the API and appear in no file. And the
+  // CLI refuses a reset while lower priority runs ("Resets can't be used while
+  // you continue at lower priority"), which is why the weekly variant stays
+  // silent once the brief has swapped to the weekly, and the grant says so.
+  const resetVariant = lp && lp.resetGrant ? lp.resetVariant || 'grant' : null;
+  const resetPressure = parts.pressure === 'tight' || parts.pressure === 'gone';
+  const fiveHourWall = Boolean(parts.binding && parts.binding.key === 'five_hour');
+  // Acknowledged is checked on its own as well as through the binding: with no
+  // weekly reading the brief cannot swap, the 5-hour window stays binding, and
+  // the reset would be offered to a session the CLI will not reset.
+  if (resetVariant === 'weekly' && resetPressure && fiveHourWall && lp.state !== 'acknowledged') {
+    sentences.push(
+      'This account is set up for a manual session reset (/limit-reset): once a week it resets the ' +
+        '5-hour limit, and the work it unlocks still counts toward the weekly, so it moves the 5-hour ' +
+        'wall rather than adding budget. The server decides whether it can be used right now, and ' +
+        "whether this week's is already used is not readable from here. Like /low-priority, only the user can type " +
+        'it; you cannot run a slash command.'
+    );
+  } else if (resetVariant === 'grant' && resetPressure) {
     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.'
+      'This account appears to hold a limit reset (/limit-reset), which the CLI describes as refilling ' +
+        'your limits while the weekly reset day stays put. How many are left and until when is not ' +
+        'readable from here - the CLI asks the server for that.' +
+        (lp.state === 'acknowledged' ? ' The CLI will not use one while lower priority is on.' : '') +
+        ' Like /low-priority, only the user can type it; you cannot run a slash command.'
     );
   }
   if (parts.session) {
@@ -1357,7 +1428,7 @@ function briefText(input) {
     // The one recommendation this session is allowed, in its short form. It
     // still cites the measurement, still names the command: terse is fewer
     // words, not less evidence.
-    const adviceText = parts.adviceText ? ' ' + parts.adviceText : '';
+    const adviceText = (parts.adviceText ? ' ' + parts.adviceText : '') + (parts.newerModel ? ' ' + parts.newerModel : '');
     return (
       sentences[0] + caveat + (parts.tier ? ' ' + parts.tier : '') + (bounded ? ' ' + bounded : '') + adviceText +
       (escapeSentence ? ' ' + escapeSentence : '') +
@@ -1524,9 +1595,17 @@ function wallFeatures(now, binding, windows, hostName) {
       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 });
       }
     }
+    // Whether the weekly really is the window the figures describe, which is
+    // what the acknowledged sentence claims. True when the swap just happened
+    // AND when the weekly was already binding on its own - the 5-hour window
+    // reading low is the ordinary case for a session that has been running at
+    // lower priority for a while. False when there was no weekly to brake on,
+    // and then the sentence has to say so instead of claiming otherwise.
+    out.lowPriority = Object.assign({}, info, {
+      weeklyBinding: Boolean(out.binding && out.binding.key === 'seven_day'),
+    });
   } catch (err) {
     // Nothing about these features is worth a failed prompt.
   }
@@ -1850,7 +1929,10 @@ async function run(now, hookInput, opts) {
   // What tier is producing this turn, and what the user's own baseline is.
   // Read, displayed, never written.
   const terse = budget.policy.briefStyle === 'terse';
-  const tier = mode.tierLine(mode.tierNow({ sessionId, now, usage, env: process.env }), { terse });
+  const tierReading = mode.tierNow({ sessionId, now, usage, env: process.env, transcriptPath: hookInput && hookInput.transcript_path });
+  const tier = mode.tierLine(tierReading, { terse });
+  // Muted advice is muted for this too: it is a recommendation like the others.
+  const newerAdvice = budget.advice && budget.advice.off ? null : mode.newerModelAdvice(tierReading, { usage, host: usage.currentHost(), bounds: budget.bounds, relayModel: relayModelNow() });
 
   // The recommendation channel. The measured fit sentence IS the
   // recommendation - it cites this account's own numbers and names the exact
@@ -1905,6 +1987,7 @@ async function run(now, hookInput, opts) {
     standingShort,
     cacheMissWhy: cacheMissWhyFor(sessionId, now),
     staleVersion: staleVersionFor(sessionId, now),
+    newerModel: newerModelFor(sessionId, newerAdvice, now),
     adviceText: terse && offering ? advice.text : null,
     relay: carry,
     voiceNote,
@@ -2011,7 +2094,7 @@ function withBugcheck(text) {
   return text;
 }
 
-module.exports = { wallFeatures, sweepDebris, withBugcheck, sayOnce, shapeOf, saidFile, REPEAT_MS, staleVersionFor, relayNewsFor, installedVersion, runningVersion,
+module.exports = { wallFeatures, sweepDebris, withBugcheck, sayOnce, shapeOf, saidFile, REPEAT_MS, staleVersionFor, newerModelFor, relayNewsFor, installedVersion, runningVersion,
   readSaid, standingSaid, markStanding, standingShortFor, STANDING_SHORT, cacheMissWhyFor, missReason, MISS_RECENT_MS,
   DEFAULTS,
   HOOK_BUDGET_MS,

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

@@ -39,13 +39,14 @@
 //   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.
+//   /limit-reset - a manual reset, behind two different server flags (see
+//   sessionReset below). tengu_nifty_lemur is the once-a-week reset of the
+//   5-hour session limit whose work still counts toward the weekly, and THIS
+//   ACCOUNT HAS IT (enabled:true). tengu_cedar_ember is a counted grant with a
+//   use-by date, absent here, with cachedUsageUtilization.utilization.cedar_ember
+//   null. Nothing is spent by the plugin - only the user can type the command -
+//   and whether this week's reset is used, or how many grants are left, is
+//   served by the API and never a file, so neither is ever 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
@@ -81,6 +82,7 @@ const atomic = require('./atomic.js');
 
 const FLAG = 'tengu_toasty_breeze';
 const RESET_FLAG = 'tengu_cedar_ember';
+const SESSION_RESET_FLAG = 'tengu_nifty_lemur';
 const WRAPUP_MODE_FLAG = 'tengu_lantern_wick_mode';
 const WRAPUP_TEXT_FLAG = 'tengu_lantern_wick_text';
 const NEAR_WALL_FLAG = 'tengu_vellum_anchor';
@@ -95,7 +97,7 @@ 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
+// exposed nowhere a hook can read, and one user has reported 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
@@ -106,6 +108,22 @@ const WEEKLY_HEADROOM_MAX = 80;
 // offers the toggle at all.
 const WALL_PERCENT = 90;
 
+// How long an acknowledgement with no readable reset time is allowed to live.
+//
+// The record is meant to lapse at the reset of the window it belongs to. When
+// that reset could not be read - a session with no account snapshot, or a
+// snapshot with no five_hour entry - the record used to be written with
+// resetsAt null, and readAck only lapsed a FINITE resetsAt. So it never lapsed:
+// a record written once went on redirecting the headroom maths at the weekly
+// for ever. Probed on 2026-09-26 with an acknowledgement three days old and the
+// 5-hour window reading 0 per cent, and the brief still said the 5-hour limit
+// "no longer stops this session".
+//
+// The window the toggle is offered at is five hours long, so an
+// acknowledgement made against it cannot honestly outlive five hours from when
+// it was made. That is the ceiling, not a guess at when it really ended.
+const ACK_MAX_MS = 5 * 60 * 60 * 1000;
+
 function configDir() {
   return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
 }
@@ -203,16 +221,53 @@ function offer(account) {
   };
 }
 
-// The manual session reset. Detected, never spent: this account holds no grant,
-// so a feature built on it would be untestable here.
+// A flag object the way the CLI reads one: a plain object whose `enabled` is
+// exactly true. The bundle's own readers are
+//   function qae(){let e=x("tengu_nifty_lemur",{});return typeof e==="object"&&e!==null&&!Array.isArray(e)?e:{}}
+//   function pme(){return qae().enabled===!0}
+// and the same shape for tengu_cedar_ember ($Z()). Truthiness is not enough:
+// `{ enabled: false }` is a truthy object, and the first build counted it as a
+// reset on offer.
+function flagEnabled(gb, key) {
+  if (!gb || !Object.prototype.hasOwnProperty.call(gb, key)) return false;
+  const value = gb[key];
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value) && value.enabled === true);
+}
+
+// The manual reset behind /limit-reset. Detected, never spent.
+//
+// There are TWO server flags behind the one command, and they describe
+// different things, so the brief must not word one in the other's terms:
+//
+//   tengu_nifty_lemur - "Reset your session limit now and keep working; once a
+//   week, still counts toward your weekly limit" (the command's description
+//   when this is the variant). Its notice: "/limit-reset to reset your session
+//   limit now · uses weekly limit · 1/week". THIS ACCOUNT HAS IT: enabled:true,
+//   version 1, read from ~/.claude.json on 2026-09-25. The first build looked
+//   only at tengu_cedar_ember, called the account grant-less, and so never said
+//   a word about a reset the account actually holds.
+//
+//   tengu_cedar_ember - "Use an available limit reset and keep working". A
+//   counted grant: "Refills your {limits} now · your weekly reset day stays
+//   {week}", "{resets} left · use by {deadline}", and an early-use path ("You
+//   haven't reached a limit yet - use your reset anyway?"). Not once a week,
+//   not only at a limit, and whether it spends the weekly is not in its copy.
+//
+// The CLI prefers cedar_ember when both are on (its description reads
+// `$Z()?"Use an available limit reset...":"Reset your session limit now..."`),
+// so this does too. Whether this week's reset is already spent, and how many
+// grants are left, come from the server and appear in no file.
 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 grantFlag = flagEnabled(gb, RESET_FLAG);
+  const weeklyFlag = flagEnabled(gb, SESSION_RESET_FLAG);
   const grant = util && util.cedar_ember ? util.cedar_ember : null;
+  const variant = grantFlag || grant ? 'grant' : weeklyFlag ? 'weekly' : null;
   return {
     known: Boolean(gb || util),
-    present: Boolean(flagged || grant),
+    present: variant !== null,
+    variant,
     // 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,
@@ -276,9 +331,13 @@ function autoContinue() {
 // session where the 5-hour wall is real again.
 // ---------------------------------------------------------------------------
 
+// An array is an object too, and JSON.stringify drops a named property set on
+// one: a state file holding `[]` made acknowledge() write `[]` straight back,
+// report saved:true, and usage-mode print "Recorded" for a statement that the
+// next read could not find. Only a plain object is a state.
 function readState() {
   const parsed = readJson(stateFile());
-  return parsed && typeof parsed === 'object' ? parsed : {};
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
 }
 
 function writeState(state) {
@@ -290,14 +349,20 @@ function writeState(state) {
   }
 }
 
+// `saved` is reported, never assumed. A state path that cannot be written -
+// a directory sitting where the file goes, a read-only home - used to return
+// the record anyway, so usage-mode printed "Recorded: you have switched
+// /low-priority on" and then the very next brief behaved as though nothing had
+// been said. Telling somebody their statement was recorded when it was not is
+// the one thing this module must not do.
 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 saved = writeState(state);
+    return { on: false, at: now, saved, file: stateFile() };
   }
   const record = {
     on: true,
@@ -307,18 +372,35 @@ function acknowledge(input) {
   };
   const state = readState();
   state.ack = record;
-  writeState(state);
-  return record;
+  const saved = writeState(state);
+  return Object.assign({}, record, { saved, file: stateFile() });
+}
+
+// When a record stops being true: the reset of the window it was stamped
+// against, or - when that could not be read - ACK_MAX_MS after it was made.
+// Both are returned as `expiresAt` so a caller never has to work it out twice
+// and get a different answer.
+function ackExpiry(ack) {
+  if (!ack) return null;
+  if (Number.isFinite(ack.resetsAt)) return ack.resetsAt;
+  if (Number.isFinite(ack.at)) return ack.at + ACK_MAX_MS;
+  return null;
 }
 
 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;
+  if (!ack || typeof ack !== 'object' || ack.on !== true) return null;
+  // A record with no usable timestamp is not a record. It printed as
+  // "acknowledged ... at Invalid Date" before this, off a hand-edited or
+  // half-written file, which is the plugin quoting garbage back as fact.
+  if (!Number.isFinite(ack.at)) return null;
+  // Past the reset of the window it was recorded against - or past the length
+  // of that window, when no reset was readable - the fact is spent.
+  const expiresAt = ackExpiry(ack);
+  if (Number.isFinite(expiresAt) && at >= expiresAt) return null;
+  return Object.assign({}, ack, { expiresAt, expiryKnown: Number.isFinite(ack.resetsAt) });
 }
 
 // Exactly three states, and activeKnown is false in every one of them.
@@ -388,6 +470,7 @@ function forBrief(input) {
     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,
+    resetVariant: sessionReset(account).variant,
     credits: credits(account),
     autoContinue: autoContinue(),
   };
@@ -396,6 +479,7 @@ function forBrief(input) {
 module.exports = {
   FLAG,
   RESET_FLAG,
+  SESSION_RESET_FLAG,
   WRAPUP_MODE_FLAG,
   WRAPUP_TEXT_FLAG,
   NEAR_WALL_FLAG,
@@ -404,12 +488,15 @@ module.exports = {
   MAX_COOLOFF_MINUTES,
   WEEKLY_HEADROOM_MAX,
   WALL_PERCENT,
+  ACK_MAX_MS,
+  ackExpiry,
   configDir,
   stateFile,
   accountFiles,
   snapshot,
   offer,
   sessionReset,
+  flagEnabled,
   wrapUp,
   credits,
   autoContinue,

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

@@ -1057,9 +1057,15 @@ function tierNow(options) {
     settings = null;
   }
 
+  // The newest assistant message is the model that actually answered, which a
+  // settings alias ('opus') cannot say. The hook's own transcript_path is read
+  // first when the caller has it: it is the file this very turn is written to,
+  // where the session-id lookup has to find it under the config directory.
   let running = null;
   try {
-    const seen = sessionId ? usage.liveModel(sessionId) : null;
+    let seen = null;
+    if (opts.transcriptPath && typeof usage.transcriptModel === 'function') seen = usage.transcriptModel(opts.transcriptPath);
+    if (!(seen && seen.model) && sessionId) seen = usage.liveModel(sessionId);
     running = seen && seen.model ? seen.model : null;
   } catch (err) {
     running = null;
@@ -1112,6 +1118,150 @@ function sameFamily(a, b) {
   return left === right;
 }
 
+// The model as the brief names it: the family and the version. It used to be
+// the family alone, so claude-opus-5 and claude-opus-5-5 both printed "opus"
+// and a switch between them - a 20% price change, 60% on cache reads - was
+// invisible in the one line that exists to say what is producing the turn. A
+// bare alias ('opus') has no version to show and is shown as it is.
+function modelLabel(name) {
+  if (!name) return null;
+  let parsed = null;
+  try {
+    parsed = require('./usage.js').parseModelId(name);
+  } catch (err) {
+    parsed = null;
+  }
+  if (parsed) return parsed.version.length ? parsed.family + ' ' + parsed.version.join('.') : parsed.family;
+  const rank = modelRank(name);
+  return rank === null ? name : MODEL_ORDER[rank];
+}
+
+// Same model for the purpose of "is the running tier the baseline". Same
+// family, and where both sides carry a version, the same version: opus 5 and
+// opus 5.5 are different models at different prices, but a baseline of the
+// bare alias 'opus' says nothing about which Opus, so it disagrees with none.
+function sameModel(a, b) {
+  if (!sameFamily(a, b)) return false;
+  let left = null;
+  let right = null;
+  try {
+    const usage = require('./usage.js');
+    left = usage.parseModelId(a);
+    right = usage.parseModelId(b);
+  } catch (err) {
+    return true;
+  }
+  if (!left || !right || !left.version.length || !right.version.length) return true;
+  return left.version.join('.') === right.version.join('.');
+}
+
+function money(value) {
+  return Number.isInteger(value) ? '$' + value : '$' + value.toFixed(2);
+}
+
+// A newer model in the SAME family at a lower price is the cheapest saving
+// there is: no step down in tier, nothing given up, only the price. The advice
+// channel above only ever says "choose lower"; this says "choose newer", once
+// per session (brief.js keeps the count), and only from prices on record.
+//
+// What the user can do differs by host, and the sentence says only what is
+// real where it is read. In Claude Code, `/model <id>` switches the session and
+// saves the model as the default for new sessions (the picker's `s` key is the
+// this-session-only form), per code.claude.com/docs/en/model-config, read
+// 2026-09-25. A subagent with no model of its own falls through to the main
+// conversation's model (docs/en/sub-agents, same day), so a switch reaches
+// those from their next dispatch. Codex has no /model of that kind, so there
+// the only lever named is its config.
+//
+// The payback figure is exact arithmetic on the two rows, not an estimate of
+// the session: switching costs one write of the context at the new model's
+// write price instead of one read at the old read price, and every later turn
+// saves the difference in read price on that context. The context size cancels
+// out of the ratio, so the number of turns holds for any session. It counts the
+// reads alone; the cheaper input and output only shorten it.
+function newerModelAdvice(tier, options) {
+  const opts = options || {};
+  if (!tier) return null;
+  const usage = opts.usage || require('./usage.js');
+  if (typeof usage.newerSibling !== 'function') return null;
+  const base = tier.baseline || {};
+  const run = tier.running || {};
+  const hostName = opts.host || host.CLAUDE;
+  // A bound the user set outranks the price: nothing said points outside it.
+  const sibling = (model) => {
+    const found = model ? usage.newerSibling(model) : null;
+    return found && allows(opts.bounds, { model: found.to }) ? found : null;
+  };
+  const current = run.model || base.model;
+  const found = sibling(current);
+  // The relay resumes with its own --model when one is set (wake.js), so a
+  // session moved to the newer model still wakes on the old one. Claude Code
+  // only: that is where `relay model` feeds a Claude CLI.
+  const relayFound = hostName === host.CLAUDE && opts.relayModel ? sibling(opts.relayModel) : null;
+  if (!found && !relayFound) return null;
+
+  const name = (family, version) => family.charAt(0).toUpperCase() + family.slice(1) + ' ' + version.join('.');
+  const pct = (was, now) => Math.round((1 - now / was) * 100);
+  const prices = (pair) => {
+    const a = pair.fromRate;
+    const b = pair.toRate;
+    const bits = [];
+    if (b.input < a.input || b.output < a.output) {
+      bits.push(money(b.input) + '/' + money(b.output) + ' per million tokens in and out against ' + money(a.input) + '/' + money(a.output));
+    }
+    if (b.cacheRead < a.cacheRead) {
+      bits.push('cache reads ' + money(b.cacheRead) + ' against ' + money(a.cacheRead) + ', ' + pct(a.cacheRead, b.cacheRead) +
+        '% less on the reads that are most of what a long session spends');
+    }
+    return bits.join('; ');
+  };
+  const family = (pair) => pair.family.charAt(0).toUpperCase() + pair.family.slice(1);
+
+  const sentences = [];
+  if (found) {
+    const a = found.fromRate;
+    const b = found.toRate;
+    sentences.push(name(found.family, found.toVersion) + ' is a newer ' + family(found) + ' at a lower price than the ' +
+      name(found.family, found.fromVersion) + ' running here. At first-party API prices: ' + prices(found) +
+      '. Same tier and a newer release, so no step down.');
+    const pinnedAlready = base.model && String(base.model).toLowerCase().replace(/\[[^\]]*\]\s*$/, '').trim() === found.to;
+    if (hostName === host.CLAUDE) {
+      sentences.push('It is the user\'s switch, not yours: offer `/model ' + found.to + '`, which moves this session and saves it as the ' +
+        'default for new sessions' + (pinnedAlready ? ' (settings.json already names it, so new sessions start on it either way)' : '') +
+        '. Subagents given no model of their own (and no CLAUDE_CODE_SUBAGENT_MODEL) run on the session\'s model, so they follow from their next dispatch.');
+      // Only where the switch can be made mid-session is its one-off cost
+      // worth a number; elsewhere the offer is a pin for new sessions, which
+      // rebuild anyway.
+      if (b.cacheRead < a.cacheRead) {
+        const turns = (write) => Math.ceil(Math.round(((write * b.input - a.cacheRead) / (a.cacheRead - b.cacheRead)) * 100) / 100);
+        sentences.push('Switching rebuilds the prompt cache once; the cheaper reads alone repay that in about ' + turns(1.25) +
+          ' turns (' + turns(2) + ' on the one-hour cache).');
+      } else {
+        sentences.push('Switching rebuilds the prompt cache once, so on a large context it is worth making at the next session start rather than now.');
+      }
+    } else if (hostName === host.CODEX) {
+      sentences.push('It is the user\'s setting, not yours: offer pinning model = "' + found.to + '" in config.toml for new sessions.');
+    } else {
+      sentences.push('It is the user\'s setting, not yours: offer choosing ' + found.to + ' in this host\'s own model setting.');
+    }
+  }
+  if (relayFound) {
+    const same = found && found.to === relayFound.to && found.from === relayFound.from;
+    sentences.push('Relay wakes are pinned to ' + opts.relayModel + ' on their own' +
+      (same ? '' : ', and ' + name(relayFound.family, relayFound.toVersion) + ' is a newer ' + family(relayFound) +
+        ' at a lower price (' + prices(relayFound) + ')') +
+      ', so a resumed run starts on the older model even after this session switches: offer `/usage-limits:relay model ' + relayFound.to +
+      '`, which is the user\'s setting too.');
+  }
+  const id = (found ? found.from + '->' + found.to : '') + (relayFound ? '|relay:' + relayFound.from + '->' + relayFound.to : '');
+  return {
+    id,
+    from: found ? found.from : null,
+    to: found ? found.to : null,
+    relay: relayFound ? { from: relayFound.from, to: relayFound.to } : null,
+    text: sentences.join(' '),
+  };
+}
 // One clause for the brief, or two lines for `--baseline`.
 //
 // Where the baseline and the running tier agree there is nothing interesting
@@ -1124,16 +1274,12 @@ function tierLine(tier, options) {
   if (!tier) return null;
   const base = tier.baseline || {};
   const run = tier.running || {};
-  const shortModel = (name) => {
-    const rank = modelRank(name);
-    return rank === null ? name : MODEL_ORDER[rank];
-  };
-  const runningText = [shortModel(run.model) || shortModel(base.model), run.effort || base.effort].filter(Boolean).join('/');
+  const runningText = [modelLabel(run.model) || modelLabel(base.model), run.effort || base.effort].filter(Boolean).join('/');
   if (!runningText) return null;
-  const baseText = [shortModel(base.model), base.effort].filter(Boolean).join('/');
+  const baseText = [modelLabel(base.model), base.effort].filter(Boolean).join('/');
   const differs =
     baseText && runningText !== baseText &&
-    (!sameFamily(run.model || base.model, base.model) || (run.effort || base.effort) !== base.effort);
+    (!sameModel(run.model || base.model, base.model) || (run.effort || base.effort) !== base.effort);
   const source = run.source ? ' (' + run.source + ')' : '';
   if (opts.terse) {
     return differs ? runningText + source + ', yours ' + baseText : runningText + source;
@@ -1505,7 +1651,12 @@ function main(argv) {
         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)) {
+        // Only a reset still ahead. A stale snapshot carries the reset of a
+        // window that has already rolled over, and stamping that on the record
+        // printed "Recorded ... lapses at" a time already gone - and the very
+        // next read found it spent, so the statement vanished. The next reset
+        // is unknown then, and the record takes the five-hour ceiling instead.
+        if (five && Number.isFinite(five.resetsAt) && five.resetsAt > now) {
           windowKey = 'five_hour';
           resetsAt = five.resetsAt;
         }
@@ -1513,7 +1664,18 @@ function main(argv) {
         // 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 });
+      const written = lowpri.acknowledge({ on: true, windowKey, resetsAt, now });
+      // A write that did not happen is never reported as one. With a directory
+      // sitting where the state file goes this said "Recorded" and the next
+      // brief behaved as though nothing had been said.
+      if (!written.saved) {
+        return [
+          'NOT recorded: ' + written.file + ' could not be written, so nothing was saved and the ' +
+            'brief will go on treating the 5-hour window as a real wall.',
+          '',
+          'Check that the path is a writable file and not a directory, then run this again.',
+        ].join('\n');
+      }
       logChange({ plane: 'mode', key: 'low-priority', from: 'unknown', to: 'on', by: 'user', reason: null }, now);
       return [
         'Recorded: you have switched /low-priority on.',
@@ -1530,14 +1692,25 @@ function main(argv) {
         '',
         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.',
+          : 'No 5-hour reset time was readable, so this lapses at ' +
+            new Date(now + lowpri.ACK_MAX_MS).toLocaleString() + ' instead - five hours, the length of ' +
+            'the window the toggle belongs to, which is the longest it could honestly still be true. ' +
+            'Run /usage and set it again if it is still on then.',
         '',
         detail,
       ].join('\n');
     }
     if (asked === 'off' || asked === 'no' || asked === 'false') {
       const had = lowpri.readAck(now);
-      lowpri.acknowledge({ on: false, now });
+      const cleared = lowpri.acknowledge({ on: false, now });
+      // The same rule as "on": a clear that did not reach the file is not
+      // reported as one, because the record it failed to remove still steers
+      // the brief at the weekly.
+      if (had && !cleared.saved) {
+        return 'NOT cleared: ' + cleared.file + ' could not be written, so the acknowledgement is still ' +
+          'there and the brief will go on braking on the weekly until it lapses at ' +
+          new Date(had.expiresAt).toLocaleString() + '. Check that the file is writable, then run this again.';
+      }
       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.'
@@ -1550,9 +1723,15 @@ function main(argv) {
     const wrap = lowpri.wrapUp(account);
     const auto = lowpri.autoContinue();
     return [
+      // readAck drops a record with no usable timestamp, so there is no longer
+      // a path that prints "at Invalid Date" here, and the expiry is always a
+      // real time: the window's reset, or five hours from the statement.
       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') + '.'
+          (Number.isFinite(ack.expiresAt)
+            ? ', lapsing at ' + new Date(ack.expiresAt).toLocaleString() +
+              (ack.expiryKnown ? ' when the 5-hour window resets' : ' (no reset time was readable, so this is five hours from the statement)')
+            : '') + '.'
         : '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 ' +
@@ -1843,6 +2022,9 @@ module.exports = {
   ultracodeName,
   topTier,
   tierLine,
+  modelLabel,
+  sameModel,
+  newerModelAdvice,
   ledger,
   explain,
   list,

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

@@ -1496,11 +1496,30 @@ async function armByHand(rest) {
   });
   if (!result.ok) return 'Could not arm: ' + result.error;
   if (text) saveContinuation(sessionId, text);
+  // armable() refuses a 5-hour wake while low-priority is acknowledged, and
+  // this path never went through it: `relay arm --session <id>` booked the wake
+  // anyway and said nothing, which is the double-start the whole gate exists to
+  // prevent. An explicit command is still honoured - it is what somebody typed
+  // - but it says what `defer reset` says, so the person deciding has the fact.
+  let lowPriorityNote = '';
+  if (binding.key === 'five_hour' && usage.currentHost() === host.CLAUDE) {
+    try {
+      if (lowpri.readAck(now)) {
+        lowPriorityNote =
+          ' Note: you have said /low-priority is on, so this session carries past the 5-hour reset ' +
+          'on its own and this wake would start the work a second time. Arm against the weekly ' +
+          'instead, or say usage-mode --low-priority off if it has ended; "relay cancel" calls this one off.';
+      }
+    } catch (err) {
+      // A missing or unreadable record is not a reason to refuse a command.
+    }
+  }
   return (
     'Armed by hand for session ' + sessionId.slice(0, 8) + ': wake at ' +
       new Date(result.record.wakeAt).toLocaleString() + ' via ' + result.record.how + '.' +
       (result.record.preflight && result.record.preflight.length ? ' Pre-answered: ' + result.record.preflight.join(', ') + '.' : '') +
-      (text ? ' Continuation saved.' : ' No continuation yet - add one with: relay note "<text>"')
+      (text ? ' Continuation saved.' : ' No continuation yet - add one with: relay note "<text>"') +
+      lowPriorityNote
   );
 }
 

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

@@ -62,6 +62,10 @@ const RATES = {
   'claude-mythos-5-1': { input: 10, output: 50, cacheRead: 0.25 },
   'claude-fable-5': { input: 10, output: 50 },
   'claude-mythos-5': { input: 10, output: 50 },
+  // Opus 5.5 prices reads outright: $0.20 is 0.05x its input, half the tenth
+  // rule every other Opus follows (platform.claude.com/docs/en/about-claude/pricing,
+  // read 2026-09-25). Left to the multiplier it would be priced at $0.40.
+  'claude-opus-5-5': { input: 4, output: 20, cacheRead: 0.2 },
   'claude-opus-5': { input: 5, output: 25 },
   'claude-opus-4-8': { input: 5, output: 25 },
   'claude-opus-4-7': { input: 5, output: 25 },
@@ -129,6 +133,83 @@ const CACHE_WRITE_5M = 1.25;
 const CACHE_WRITE_1H = 2;
 const CACHE_READ = 0.1;
 
+// The effective cache-read price of a row, in $/MTok.
+function readRateOf(rate) {
+  return Number.isFinite(rate.cacheRead) ? rate.cacheRead : rate.input * CACHE_READ;
+}
+
+// A model id taken apart into the family word and the version numbers:
+// 'claude-opus-5-5' is opus [5, 5], 'us.anthropic.claude-opus-5-v1:0' is
+// opus [5]. A dated snapshot suffix (20250929) is not part of the version, and a
+// bare alias such as 'opus' has no version at all, so nothing is claimed about
+// which release it resolved to. Mythos stays mythos here: it is priced with
+// Fable, but it is not the same model line.
+function parseModelId(model) {
+  const id = normalizeModel(model);
+  const found = id.match(/(haiku|sonnet|opus|mythos|fable)((?:-\d+)*)/);
+  if (!found) return null;
+  const version = [];
+  for (const part of found[2].split('-').filter(Boolean)) {
+    if (part.length > 2) break;
+    version.push(Number(part));
+  }
+  return { family: found[1], version };
+}
+
+function compareVersions(a, b) {
+  const length = Math.max(a.length, b.length);
+  for (let i = 0; i < length; i += 1) {
+    const diff = (a[i] || 0) - (b[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+// Claude 4.7 and later count text with a newer tokenizer that produces about
+// 30% more tokens for the same text (pricing page, read 2026-09-25). A price per
+// token across that line is not a like-for-like price, so a sibling on the other
+// side of it is never offered as the cheaper one.
+function sameTokenizer(a, b) {
+  return (compareVersions(a, [4, 7]) >= 0) === (compareVersions(b, [4, 7]) >= 0);
+}
+
+// The newest release of the SAME family that is newer than this one and no
+// dearer on any rate - input, output or cache reads - and cheaper on at least
+// one. That is a saving with no step down in tier. Only a model whose own price
+// is on record qualifies: comparing against a family average would be
+// comparing against a guess.
+function newerSibling(model, table) {
+  const rates = table || RATES;
+  const me = parseModelId(model);
+  if (!me || !me.version.length) return null;
+  const from = 'claude-' + me.family + '-' + me.version.join('-');
+  const mine = rates[from];
+  if (!mine) return null;
+  let best = null;
+  for (const id of Object.keys(rates)) {
+    const other = parseModelId(id);
+    if (!other || other.family !== me.family || !other.version.length) continue;
+    if (compareVersions(other.version, me.version) <= 0) continue;
+    if (!sameTokenizer(other.version, me.version)) continue;
+    const theirs = rates[id];
+    const noDearer = theirs.input <= mine.input && theirs.output <= mine.output && readRateOf(theirs) <= readRateOf(mine);
+    const cheaper = theirs.input < mine.input || theirs.output < mine.output || readRateOf(theirs) < readRateOf(mine);
+    if (!noDearer || !cheaper) continue;
+    if (!best || compareVersions(other.version, best.version) > 0) best = { id, version: other.version, rate: theirs };
+  }
+  if (!best) return null;
+  const shape = (rate) => ({ input: rate.input, output: rate.output, cacheRead: readRateOf(rate) });
+  return {
+    family: me.family,
+    from,
+    fromVersion: me.version,
+    fromRate: shape(mine),
+    to: best.id,
+    toVersion: best.version,
+    toRate: shape(best.rate),
+  };
+}
+
 // `family` marks a window that caps one model family rather than the account
 // as a whole. It is what tells the rest of the file that a window cannot stop
 // work which does not use that family.
@@ -4282,6 +4363,8 @@ module.exports = {
   WINDOWS,
   rateFor,
   familyOf,
+  parseModelId,
+  newerSibling,
   familyAverage,
   familiesInUse,
   appliesTo,

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

@@ -559,8 +559,17 @@ function mine(held, record) {
 }
 
 async function run(now, argv, overrides) {
+  // `reachable` belongs in here with the rest. Left out, the preflight below
+  // called the real network on every run of the retry tests, so the whole
+  // launch-failure suite passed only on a machine that could reach
+  // api.anthropic.com - and went red, in the offline branch, on a laptop with
+  // its wifi off or behind a TLS-inspecting proxy. That is the exact condition
+  // the relay is built for, so it is the last thing its tests should need.
   const deps = Object.assign(
-    { windowReopened, deliverClaude, deliverCodex, toast, userIsPresent, arm: relay.arm, capabilities: relay.capabilities },
+    {
+      windowReopened, deliverClaude, deliverCodex, toast, userIsPresent,
+      arm: relay.arm, capabilities: relay.capabilities, reachable: net.reachable,
+    },
     overrides || null
   );
   const id = argOf(argv, '--id');
@@ -618,7 +627,7 @@ async function run(now, argv, overrides) {
   // So: ask first, before spending a launch on it, and give being offline its
   // own much longer budget. A machine that cannot reach the API has not failed.
   // It is waiting, and waiting is free.
-  const link = await net.reachable({ timeoutMs: 8000 });
+  const link = await deps.reachable({ timeoutMs: 8000 });
   if (!link.online) {
     const offlineAttempt = (record.offlineAttempt || 0) + 1;
     if (offlineAttempt <= config.offlineAttempts) {