claude-usage-limits 1.40.4 → 1.41.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "usage-limits",
   "displayName": "Usage Limits",
-  "version": "1.40.4",
+  "version": "1.41.0",
   "description": "Puts your remaining Claude Code usage limit into Claude's context before every prompt, so it opens with what fits in the budget instead of starting work that gets cut off. Reports headroom as turns rather than percentages, prices a job before you start it, and detects your plan tier.",
   "author": {
     "name": "Ridelink",

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "usage-limits",
-  "version": "1.40.4",
+  "version": "1.41.0",
   "description": "Reports how much of your Codex usage limit is left as turns of work rather than a percentage, prices a job before you start it, and counts the other agents sharing the same budget.",
   "author": {
     "name": "Ridelink",

package/README.md

@@ -19,6 +19,21 @@ opens with the answer instead:
 
 Nobody read a chart to get that. The numbers reached the model, not you.
 
+![The usage report: the 5-hour window is binding with about 44 turns left, and at the current pace it runs out 38 minutes before the reset.](docs/img/usage-report.png)
+
+<sub>Real output of `npx claude-usage-limits` on the author's machine, 2026-09-26: the Claude Code windows and the closing verdict, with the Codex and per-model sections left out. The plugin puts the same reading into Claude's context, as the budget line, before every prompt.</sub>
+
+Install it as a Claude Code plugin:
+
+```
+/plugin marketplace add ridelink0/claude-code-usage-limits
+/plugin install usage-limits@usage-limits
+```
+
+Or see the report without installing anything: `npx claude-usage-limits`.
+Codex, the plain-skill route and keeping it updated are under
+[Install](#install).
+
 ## What it runs on your machine, and what it never does
 
 Installing this plugin registers six Claude Code hooks, which means Node runs on
@@ -1120,7 +1135,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
@@ -1321,18 +1352,6 @@ percentage and any pressure, the `max` line must never be longer than the
 worse, and every mode path, alias, bound and guard is exercised before
 `settings.json` is compared byte for byte.
 
-## Status
-
-It works and I use it daily.
-
-What I am not doing is fielding feature requests or support questions. If you
-want it to behave differently, fork it and change it, which is what the MIT
-licence is there for. Do not wait on me to add something for you.
-
-## License
-
-MIT. See [LICENSE](LICENSE).
-
 ## The wall is not the end of the budget
 
 A full window is not always a reason to stop, and the plugin now says which.
@@ -1363,119 +1382,20 @@ line said the budget was nearly gone, and the work stopped - with the 5-hour
 window at 46 and every other model untouched. One command would have carried it
 on.
 
-## 1.23.0 - the ceiling, and three hosts that can be told no
-
-Everything before this release reported. This one intervenes.
-
-### The Codex meter was going blind about a third of the time
-
-Codex writes more than one meter into its rollouts, and they are not successive
-readings of one thing. A ChatGPT Plus session carries `limit_id: "codex"`, which
-holds the 5-hour and weekly windows, interleaved with `limit_id: "premium"`,
-which holds the credit balance and has `primary` and `secondary` set to `null`.
-The reader took whichever was written last.
-
-On the machine this was found on, two of every six rollouts ended on a `premium`
-payload - and when one did, the plugin reported no windows at all. Measured on a
-real session: the final line was a `premium` payload two lines after a `codex`
-payload reading **99 per cent of the 5-hour window**, and what reached the agent
-was a meter with nothing in it.
-
-That is the whole of "Codex does not slow down when the limit is close": nothing
-ever told it the limit was close. The reader now keeps the newest reading of each
-meter and prefers the one that actually describes a window. Nothing is merged or
-synthesised - the payload returned is one Codex really wrote.
-
-### An old snapshot is an estimate, not a reading
-
-There was already a warning for a reading spent past its own remainder. It could
-never fire for a snapshot taken at the start of a window, because everything
-spent since is still inside the remainder.
-
-So a session ran for most of an hour being told **7 per cent** while the account
-was at **41**: Claude Code's own cache had not moved in fifty minutes, the
-plugin's live reading was rate-limited into backoff, and the correction was
-quietly carrying the entire difference on its own. A correction is a good
-adjustment to a recent snapshot and a bad substitute for an old one, because the
-pricing error compounds with every point it has to bridge. Past fifteen minutes
-the brief now says the figure is an estimate that can run high or low and points
-at `/usage`. It is only called a floor when the correction has been refused
-outright and the raw snapshot is all that is shown, since that really is a
-lower bound; a snapshot plus a correction is not, and on 2026-09-20 it ran 13
-to 17 points high.
-
-### The ceiling
-
-    node bin/cli.js mode --cap 60
-    node bin/cli.js mode --cap off
-
-Past the ceiling, **fan-out calls are refused at the hook** - `Agent`, `Task`,
-`Workflow` and their equivalents on each host. Everything else keeps working at
-any percentage: reads, edits, tests, commands. The work still finishes, just
-sequentially, in one session, which is where the saving is. A measured fan-out
-costs between 2.6x and 5.9x the same work done in sequence, because every agent
-warms its own cache from cold and none can report back until they all stop.
-
-It is off until you set a number, it never fires without a reading behind it, and
-the refusal says what to do instead - a denial that only says "over budget" gets
-retried.
-
-It is judged on the fullest window this session can spend into, and the refusal
-names that window. A weekly scoped to one model counts only while that model
-runs - by the setting, or by the model the session's last reply came from, so a
-`/model` switch is seen - and a window whose reset has passed does not count.
-Until 1.39.0 it took the highest number on disk, and an Opus session was refused
-on the Fable weekly with a message calling it "the binding window".
-
-**Why a refusal rather than a sentence.** On Codex the reported figure
-demonstrably does not change behaviour, and the reason is not stubbornness.
-`gpt-6-astra`'s own system prompt, shipped in `models_cache.json`, says: *"Do not
-settle for a partial or 'helpful enough' solution that does not fully satisfy the
-user's task to save time, effort or tokens"* - and ranks the live user
-instruction above anything an `AGENTS.md` or a skill says. A line asking it to
-economise is arguing with its own instructions, and losing.
-
-### The Codex subagent clamp
-
-`lowpower on --host codex` now also bounds `[agents]`. Two facts read out of the
-model catalog Codex itself caches, not out of documentation:
-
-    gpt-6-astra: default_reasoning_level    = "low"
-                 multi_agent_reasoning_effort = "xhigh"
-
-Astra's own default effort is the cheapest one, and its subagents run at the
-dearest one **no matter what the session is set to**. Lowering effort without
-bounding them leaves the most expensive path in the product untouched. The clamp
-is a marked block, removed exactly by `lowpower off`, and it refuses outright
-rather than writing a second `[agents]` table over one you wrote yourself.
-`--no-agents` declines just that half.
-
-### Antigravity
-
-    node skills/usage-limits/scripts/install-antigravity.js on
-
-Installs into `~/.gemini/config/plugins/usage-limits/`. `PreInvocation` carries
-the budget line as an injected ephemeral message; `PreToolUse` carries the
-ceiling, which Antigravity implements as a real `decision: "deny"`.
-
-One thing is said plainly rather than papered over: **Antigravity publishes no
-remaining quota anywhere readable on disk.** It refreshes quota - its own log
-says so - and keeps it in memory. A previous version filled that gap by reporting
-*Claude's* meter under a `cross-agent-claude` source, next to a hardcoded plan
-and a model name invented for a settings file that has no model key in it. All of
-that is gone. Where there is nothing to read, the report says the quota is
-unreadable.
-
-### Caveman, and why it is not here
-
-It was on the list for this release and it is not in it. JetBrains ran a
-controlled A/B of the caveman skill - 86 tasks, paired, ~240 billed trials - and
-measured output tokens down **8.5 per cent** against an advertised 65, with
-quality differences indistinguishable from noise (p=0.82). An independent
-benchmark found the literal instruction `be brief.` matched or beat it, and
-because agentic cost is input-dominated, the skill's own rules riding along every
-turn can cost more than they save. Its engine is also BSL-licensed, not open.
-
-Claude Code already ships a built-in **Concise** output style that does the same
-job in the cached system-prompt layer at no marginal cost. Use that. This plugin
-will not ship a measured 8 per cent as a 65 per cent saving.
+## Release notes
+
+What changed in each version is in the [GitHub Releases](https://github.com/ridelink0/claude-code-usage-limits/releases).
+The long notes for 1.23.0, the release that started intervening rather than
+only reporting, are in [docs/1.23.0.md](docs/1.23.0.md).
+
+## Status
+
+It works and I use it daily.
+
+What I am not doing is fielding feature requests or support questions. If you
+want it to behave differently, fork it and change it, which is what the MIT
+licence is there for. Do not wait on me to add something for you.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

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.4",
+  "version": "1.41.0",
   "description": "Puts your remaining Claude Code usage limit into Claude's context before every prompt, so it opens with what fits in the budget instead of starting work that gets cut off. Reports headroom as turns rather than percentages, prices a job before you start it, and detects your plan tier.",
   "keywords": [
     "claude",

package/skills/usage-limits/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) {
@@ -1228,15 +1253,20 @@ function briefText(input) {
   // (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.
+  // session that will be CLOSED. Both firing for the same reset would run the
+  // work twice and spend the weekly twice, so since 1.41.0 the wake looks for
+  // this session's process first and stands down when it is open and working
+  // again (wake.js, liveSession). What the CLI does NOT do is continue a session
+  // that stopped short of the wall, at a cap, so that case is said too.
   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.'
+        '), so if this terminal is still open when the limit is hit, the CLI carries THIS session across ' +
+        'the reset 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 the wake checks for this session first and opens no second ' +
+        'window while it is open and working again. The CLI does not continue a session that stopped short ' +
+        'of the limit (at a cap); the wake gives such a session a few minutes, then opens it in one window.'
     );
   }
   if (carry && carry.last) {
@@ -1403,7 +1433,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 : '') +
@@ -1904,7 +1934,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
@@ -1959,6 +1992,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,
@@ -2065,7 +2099,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/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;
@@ -1876,6 +2022,9 @@ module.exports = {
   ultracodeName,
   topTier,
   tierLine,
+  modelLabel,
+  sameModel,
+  newerModelAdvice,
   ledger,
   explain,
   list,

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

@@ -904,19 +904,50 @@ function verifyRegistration(state, next, wanted, now) {
   return { ok: true, nextRun: at };
 }
 
-const HIDDEN_HOST = path.join(process.env.SystemRoot || 'C:' + path.sep + 'Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+const SYSTEM32 = path.join(process.env.SystemRoot || 'C:' + path.sep + 'Windows', 'System32');
+const HIDDEN_HOST = path.join(SYSTEM32, 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+const HEADLESS_HOST = path.join(SYSTEM32, 'conhost.exe');
+
+// conhost --headless arrived with the pseudoconsole in Windows 10 1809 (build
+// 17763). Older builds, and anything that is not Windows, keep the PowerShell
+// route alone.
+function headlessAvailable() {
+  if (process.platform !== 'win32') return false;
+  const build = Number(String(os.release()).split('.')[2]);
+  return Number.isFinite(build) && build >= 17763 && fs.existsSync(HEADLESS_HOST);
+}
 
 // The task used to run node.exe directly, and node.exe is a console program:
 // under the scheduler, in an interactive session, it gets a console window
 // of its own. That was the "blank terminal that says Claude" - the wake's own
 // console, shared by its headless child - and closing it killed both (task
-// result 0xC000013A), so the wake never wrote its outcome. PowerShell can
-// start hidden and node inherits that; the session the wake opens for the
-// user is a new window (cmd /c start) and stays visible.
-function hiddenAction(launcher, cwd) {
+// result 0xC000013A), so the wake never wrote its outcome.
+//
+// PowerShell's -WindowStyle Hidden was the first fix, and it only works where
+// the old console host draws the window. Windows 11 hands every new console to
+// Windows Terminal by default, and Terminal ignores the flag: measured
+// 2026-09-27, the task opened a "powershell.exe" Terminal window beside the
+// Claude window the wake started, so the user saw two terminals for one relay
+// and closing the wrong one killed the wake again (0xC000013A the same
+// evening). conhost --headless gives the console no window at all, so there
+// is nothing to hand to Terminal; measured the same evening, the same task
+// under it opened no window, and the session window the wake opens (cmd /c
+// start) still appeared, alone.
+function hiddenAction(launcher, cwd, headless) {
+  const useHeadless = headless === undefined ? headlessAvailable() : headless;
+  const run = '-Command "& ' + psQuote(launcher) + '"';
+  if (useHeadless) {
+    // No -WindowStyle here: there is no window to style, and the 20 characters
+    // matter to the schtasks fallback, which refuses a /TR over 261.
+    return {
+      execute: HEADLESS_HOST,
+      argument: '--headless "' + HIDDEN_HOST + '" -NoProfile -NonInteractive ' + run,
+      cwd: cwd || os.homedir(),
+    };
+  }
   return {
     execute: HIDDEN_HOST,
-    argument: '-NoProfile -NonInteractive -WindowStyle Hidden -Command "& ' + psQuote(launcher) + '"',
+    argument: '-NoProfile -NonInteractive -WindowStyle Hidden ' + run,
     cwd: cwd || os.homedir(),
   };
 }
@@ -1884,7 +1915,7 @@ if (require.main === module) {
     );
 }
 
-module.exports = { workWithContinuation, reapLost, hiddenAction, BUGCHECK_LINE,
+module.exports = { workWithContinuation, reapLost, hiddenAction, headlessAvailable, HEADLESS_HOST, HIDDEN_HOST, BUGCHECK_LINE,
   taskAction, wakeLauncherFile, wakeLauncherScript, writeWakeLauncher, sweepWakeLaunchers, batchArg, describeSpawn, PS_ROUTE_MS, SCHTASKS_MS,
   records, armedFor, putRecord, dropRecord, preflightPrompts, claudeJsonFile, projectKeys, isHome, launchDirFor, applySetting, settingIs,
   DEFAULTS,

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

@@ -308,6 +308,106 @@ function transcriptExists(id) {
   return false;
 }
 
+function transcriptFile(id) {
+  const root = path.join(relay.configDir(), 'projects');
+  try {
+    for (const dir of fs.readdirSync(root)) {
+      const file = path.join(root, dir, id + '.jsonl');
+      if (fs.existsSync(file)) return file;
+    }
+  } catch (err) {
+    // No projects folder at all.
+  }
+  return null;
+}
+
+// ONE TERMINAL.
+//
+// The session a relay was armed for is often still open. Claude Code's own
+// autoContinueAtUsageLimit (on by default) carries an open session across the
+// reset in place, and a wake that opened `claude --resume` beside it put two
+// terminals on the screen running the same conversation - the same work
+// started twice and the weekly spent twice. Gev, 2026-09-27: "fix it to where
+// it makes 1 terminal and not 2".
+//
+// Claude Code keeps one file per running process in <config>/sessions,
+// named for the pid: { pid, sessionId, procStart, kind, cwd, ... }. procStart
+// is the process creation time (a Windows FILETIME, read against
+// Get-Process on 2026-09-27: 134350239768728478 on both sides), which is what
+// tells a live session from a dead one whose pid Windows has handed to
+// something else. A file whose process is gone is left where it is: it is
+// Claude Code's, not the relay's.
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === 'EPERM';
+  }
+}
+
+function processStart(pid) {
+  if (process.platform !== 'win32') return null;
+  const shell = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+  const run = spawnSync(shell, ['-NoProfile', '-NonInteractive', '-Command', '(Get-Process -Id ' + Number(pid) + ' -ErrorAction Stop).StartTime.ToFileTimeUtc()'], {
+    encoding: 'utf8',
+    timeout: 30000,
+    windowsHide: true,
+  });
+  const said = String(run.stdout || '').trim();
+  return run.status === 0 && /^\d+$/.test(said) ? said : null;
+}
+
+function liveSession(id, io) {
+  const ops = Object.assign({ alive: pidAlive, started: processStart }, io || null);
+  const dir = path.join(relay.configDir(), 'sessions');
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch (err) {
+    return null;
+  }
+  for (const name of names) {
+    if (!/^\d+\.json$/.test(name)) continue;
+    let held;
+    try {
+      held = JSON.parse(fs.readFileSync(path.join(dir, name), 'utf8'));
+    } catch (err) {
+      continue;
+    }
+    if (!held || held.sessionId !== id) continue;
+    const pid = Number(held.pid);
+    if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) continue;
+    if (!ops.alive(pid)) continue;
+    // A start time that can be read and does not match is a recycled pid.
+    // One that cannot be read (not Windows, or the query failed) leaves the
+    // pid's word as the answer.
+    if (held.procStart) {
+      const started = ops.started(pid);
+      if (started !== null && String(started) !== String(held.procStart)) continue;
+    }
+    return { pid, kind: held.kind || null, cwd: held.cwd || null };
+  }
+  return null;
+}
+
+// Written to since `since`: the open session is working again, which is what
+// the CLI's own continue looks like from outside.
+function transcriptActiveSince(id, since) {
+  const file = transcriptFile(id);
+  if (!file) return false;
+  try {
+    return fs.statSync(file).mtimeMs >= since;
+  } catch (err) {
+    return false;
+  }
+}
+
+// How long a wake that finds the session open but quiet waits for it to start
+// working by itself before opening the one window it would have opened anyway.
+const LIVE_WAIT_MS = 3 * MINUTE;
+const LIVE_POLL_MS = 15 * 1000;
+
 function readExit(file) {
   try {
     const code = parseInt(fs.readFileSync(file, 'utf8').trim(), 10);
@@ -569,6 +669,7 @@ async function run(now, argv, overrides) {
     {
       windowReopened, deliverClaude, deliverCodex, toast, userIsPresent,
       arm: relay.arm, capabilities: relay.capabilities, reachable: net.reachable,
+      liveSession, transcriptActiveSince, sleep: sleepMs, now: Date.now,
     },
     overrides || null
   );
@@ -615,6 +716,35 @@ async function run(now, argv, overrides) {
     return { outcome: 'rescheduled', attempt };
   }
 
+  // ONE TERMINAL (see liveSession). An open session that is working again -
+  // written to since the window reset - has been carried across by the CLI,
+  // and a second window would run the same work twice, so the wake stands
+  // down. One that is open but quiet gets LIVE_WAIT_MS to start by itself
+  // (the CLI's continue, or the session's own timer); if it is closed in that
+  // time, or stays quiet, the wake opens its one window, because nothing
+  // outside a session can type into it and the plan still has to run.
+  if (record.host !== host.CODEX) {
+    const since = Number.isFinite(record.wakeAt) ? record.wakeAt - (config.graceMinutes || 0) * MINUTE : now - 5 * MINUTE;
+    const started = deps.now();
+    let open = deps.liveSession(record.id);
+    while (open) {
+      if (deps.transcriptActiveSince(record.id, since)) {
+        deps.toast(
+          'Usage limits: carried on in place',
+          (record.project || path.basename(record.cwd)) + ' is still open and working again in its own terminal, so no second window was opened.'
+        );
+        finish(state, record, 'live', 'the session is open in process ' + open.pid + ' and working again; no second window', now);
+        return { outcome: 'live', pid: open.pid };
+      }
+      if (deps.now() - started >= LIVE_WAIT_MS) break;
+      deps.sleep(LIVE_POLL_MS);
+      open = deps.liveSession(record.id);
+    }
+    if (open) {
+      relay.note('wake ' + record.id + ': the session is open in process ' + open.pid + ' but idle since the reset; opening it in a window', now);
+    }
+  }
+
   // THE PREFLIGHT.
   //
   // The retry above is the right shape but the wrong budget for the failure it
@@ -848,4 +978,4 @@ if (require.main === module) {
   );
 }
 
-module.exports = { launcherScriptPosix, shQuote, visibleArgs, launcherScript, pointerPrompt, transcriptExists, wakePromptFile, LAUNCH_GRACE_MS, run, toast, userIsPresent, claudeArgs, deliverClaude, deliverCodex, windowReopened, argOf, appendRun, spawnOptionsFor };
+module.exports = { liveSession, transcriptActiveSince, pidAlive, LIVE_WAIT_MS, LIVE_POLL_MS, launcherScriptPosix, shQuote, visibleArgs, launcherScript, pointerPrompt, transcriptExists, wakePromptFile, LAUNCH_GRACE_MS, run, toast, userIsPresent, claudeArgs, deliverClaude, deliverCodex, windowReopened, argOf, appendRun, spawnOptionsFor };