claude-usage-limits 1.11.6 → 1.13.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "usage-limits",
   "displayName": "Usage Limits",
-  "version": "1.11.6",
+  "version": "1.13.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.11.6",
+  "version": "1.13.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

@@ -168,6 +168,50 @@ node skills/usage-limits/scripts/usage.js
 node skills/usage-limits/scripts/usage.js --json
 ```
 
+### Keeping it up to date
+
+Claude Code can update this for you, but **it will not by default**. Auto-update
+is a per-*marketplace* switch, and it defaults to on only for claude.ai-hosted
+marketplaces and a hard-coded list of official Anthropic ones. Every
+third-party GitHub marketplace, this one included, defaults to off.
+
+Turn it on once, either through `/plugin` → Marketplaces → usage-limits, or by
+adding one key to `~/.claude/settings.json`:
+
+```json
+{
+  "extraKnownMarketplaces": {
+    "usage-limits": {
+      "source": { "source": "github", "repo": "ridelink0/claude-code-usage-limits" },
+      "autoUpdate": true
+    }
+  }
+}
+```
+
+Claude Code then refreshes the marketplace and updates the plugin in the
+background shortly after a session starts (with a random delay of up to ten
+minutes, so a running session keeps the version it launched with), and offers
+`/reload-plugins` when something changed. To update on the spot instead:
+
+```
+claude plugin update usage-limits
+```
+
+Note that the whole pass is skipped when Claude Code's own auto-updater is
+disabled, unless `FORCE_AUTOUPDATE_PLUGINS` is set.
+
+**Cloud and web sessions** never see `~/.claude`, so nothing installed on a
+laptop reaches them. Commit the same block to a repository's
+`.claude/settings.json`, alongside `enabledPlugins`, and any session opened on
+that repository installs the plugin at session start — always at the newest
+commit. This repository carries exactly that file if you want one to copy.
+
+The other two channels update themselves the ordinary way: the VS Code
+extension through the Marketplace, and the npm package on the next `npx
+claude-usage-limits` (a global install pins, so `npm i -g claude-usage-limits@latest`
+to move it).
+
 ## When another Claude is working too
 
 Two Claude Code windows share one limit, so headroom measured in turns is
@@ -264,6 +308,87 @@ The skill also requires Claude to say up front when a job will not fit in what
 is left, name what it is doing now, what it is leaving, and when the rest can
 happen, rather than starting and stopping halfway through an edit.
 
+## The relay: carrying a project across the reset
+
+The handoff has always had the same flaw. It gets written, and then it sits in
+a closed terminal until somebody comes back and reads it. Everything the
+session knew — the files it had open, the half-made decision, the reason the
+second approach was abandoned — expires with the window.
+
+The relay closes that gap. Once the binding window passes a threshold you set,
+**and** the session has an unfinished todo list or an approved plan to carry,
+it books a one-shot wake for a few minutes after the reset. Arming costs
+nothing and changes nothing about the work in progress; that is the point,
+because nobody should slow down to prepare for a wall. Then, at the wake, it
+re-checks the meter and hands your continuation back.
+
+```
+/usage-limits:relay on
+/usage-limits:relay mode resume
+/usage-limits:relay permission acceptEdits
+```
+
+What changes while it is armed is what Claude is told at the wall. Instead of
+"write the handoff and stop", the budget line says the relay has it, that being
+cut off now costs the wait rather than the work, and that the continuation is a
+prompt to be acted on rather than a summary for a person to read.
+
+| | |
+| --- | --- |
+| **Off by default** | Scheduling an agent to run while nobody is watching is a decision you make on purpose, not one a plugin makes for you. |
+| **Only with work to carry** | It reads the session's own todo list and approved plan out of the transcript. An idle chat is not a project and never arms. |
+| **`notify` by default** | It raises a notification with the continuation ready to open, and starts nothing. `mode resume` is the opt-in that runs the CLI itself. |
+| **It re-checks the meter** | The reset time is a prediction; the meter is the fact. If the window has not actually turned over it books another wake rather than spending the first minute of a fresh window on a refusal. |
+| **It survives sleep** | Registered through the ScheduledTasks module with `StartWhenAvailable` and `WakeToRun`, so a machine asleep at the moment fires on wake instead of missing it silently. |
+| **It cleans up after itself** | The task carries an expiry, and the wake unregisters it once the outcome is recorded. |
+| **Codex too** | `codex queue --thread` puts the continuation into a live session; `codex exec resume` revives a dead one. |
+
+Two honest limits:
+
+- **It cannot type into your terminal.** If Computer Use is installed the relay
+  uses it to tell whether you are at the keyboard — and if you are, it leaves a
+  notification instead of starting a second agent in the directory you are
+  working in. It does not send keystrokes to a shell or an editor, because that
+  plugin refuses to on purpose and routing around a safety rule because it is
+  inconvenient is how safety rules stop meaning anything.
+- **Claude Code's own `autoContinueAtUsageLimit` is better where it applies.**
+  It waits inside the open session, so the process never dies and no context is
+  reconstructed. It is documented not to offer the wait for `-p` runs or
+  background sessions, and it cannot help a terminal that has been closed or a
+  machine that slept — and it sends a fixed prompt of its own rather than the
+  plan your session actually wrote. That is the gap this fills.
+
+`/usage-limits:relay` on its own reports where it stands: whether it is on,
+what is armed, when it wakes, what is available on this machine, and what the
+last relay actually did.
+
+## Voice: so the prompt it writes sounds like you
+
+The prompt that restarts your work is written by the plugin, not by you. A
+prompt that reads like a form letter gets a reply that reads like a form
+letter, so the plugin keeps a small profile of how you write and uses it there.
+
+It is counters — message length, how often you start lowercase, whether you end
+with a full stop, dropped apostrophes, capitals for emphasis, how you open —
+plus at most two short lines of your own text kept as examples. No model call
+is involved, nothing leaves the machine, and it says nothing at all until it
+has seen a dozen prompts, because style measured on less than that is noise.
+
+```
+/usage-limits:voice                       what it knows, including the kept lines
+/usage-limits:voice set "blunt, no preamble"
+/usage-limits:voice forget                deletes it outright
+```
+
+`set` is the other half, and the more useful one: it is not what the plugin
+learned about you, it is you saying how you want to be talked to. It goes in
+front of every prompt and it wins over anything learned.
+
+One deliberate omission: misspellings. They are the most individual thing in
+anyone's writing and the worst thing to put in a prompt — told that somebody
+makes mistakes, a model makes mistakes everywhere. Only patterns that are
+choices are recorded, and the card says outright not to introduce errors.
+
 ## Releasing
 
 ```
@@ -661,9 +786,14 @@ today; and the hooks themselves, ready for the build that runs them. `status`
 reports both, `off` removes both, and neither touches anything else in those
 files.
 
-The practical difference is that under Codex the budget is read deliberately,
-once at the start of a piece of work, rather than being handed to you before
-every prompt.
+The practical difference is that under Codex the budget is read deliberately
+rather than being handed to you before every prompt: once at the start of a
+piece of work, again every ten or so tool-heavy turns and before the last long
+step, and when the turns left are fewer than the steps still ahead the block
+tells Codex to stop at a clean boundary, write WORK-PLAN.md and commit rather
+than run into the limit. That last rule exists because a Codex session on
+7 September 2026 read "about 32 turns left", carried on through forty minutes
+of publishing, and was cut off with the handoff unwritten.
 
 Two smaller differences. There is no money column: Codex meters a share of an
 allowance and never quotes a price, so the percentages stand alone. And

package/bin/cli.js

@@ -29,6 +29,7 @@ const HELP = `claude-usage-limits - how much agent usage is left, and whether th
   claude-usage-limits lowpower status     show the current effort setting
   claude-usage-limits lowpower on         lower effortLevel, remembering the old value
   claude-usage-limits lowpower on --effort medium --model sonnet
+  claude-usage-limits lowpower on --host codex --effort low
   claude-usage-limits lowpower off        put back exactly what was there
 
   claude-usage-limits codex-hook status   is the Codex prompt hook installed

package/commands/relay.md

@@ -0,0 +1,45 @@
+---
+description: Carry the current project across the usage reset - arm, check or cancel the automatic pick-up
+---
+
+The relay books a one-shot wake a few minutes after the usage window resets and
+hands your continuation back then, instead of the work ending when the budget
+does. It is off until you turn it on, and it only ever arms while the session
+has an unfinished todo list or an approved plan to carry.
+
+Run `node "${CLAUDE_PLUGIN_ROOT}/skills/usage-limits/scripts/relay.js" $ARGUMENTS`
+(add `--host codex` under Codex) and read the answer back.
+
+With no arguments that prints the status: whether it is on, where it arms, what
+is armed right now, when it wakes, and what the last relay did.
+
+The rest:
+
+- `on` / `off` - the master switch.
+- `at 75` - the percentage of the binding window at which a wake is booked.
+  Arming costs nothing and does not change the work, so this is deliberately
+  well below the wall.
+- `grace 5` - minutes after the reset before the wake fires. The reset time is
+  when the window opens; a request one second later has been refused before.
+- `mode notify` - raise a notification with the continuation ready to open.
+  This is the default and it starts nothing by itself.
+- `mode resume` - at the wake, run the CLI in the project directory and hand
+  the continuation back to the same conversation. Say `permission acceptEdits`
+  (or whichever mode you want) as well: a headless resume does **not** inherit
+  the session's permission mode, so without one it will sit waiting for an
+  approval nobody is there to give.
+- `thinking off|resume|always` - `resume` puts the word ultrathink into the
+  prompt the relay delivers. `always` sets `alwaysThinkingEnabled` in your
+  settings, backs the file up first, and applies to new sessions.
+- `note "<text>"` (or `note --file <path>`) - store the continuation. This is
+  the text that gets delivered, so write it to be acted on: what is done, what
+  is next in order, which files are mid-change, what to verify first.
+- `cancel` - drop the wake and remove the scheduled task.
+- `log` - the last twenty lines of what the relay actually did.
+
+If the user asks for something the relay cannot do, say so rather than
+approximating it. In particular it cannot type into a terminal or an editor:
+Computer Use refuses to send input to a shell on purpose, and the relay uses it
+only to tell whether somebody is at the keyboard.
+
+Report the answer and stop. Do not start other work as part of this command.

package/commands/voice.md

@@ -0,0 +1,33 @@
+---
+description: Show, set or delete what the plugin has learned about how you write
+---
+
+The plugin watches the prompts you type and keeps a small profile of how you
+write - message length, punctuation, capitals, openings, contractions. No model
+call is involved and nothing leaves the machine: it is counters, plus at most
+two short lines of your own text kept as examples.
+
+It exists so that text written on your behalf sounds like you. The one place
+that happens today is the relay: when a project is carried across a usage
+reset, the prompt that restarts it is written by the plugin, not by you.
+
+Run `node "${CLAUDE_PLUGIN_ROOT}/skills/usage-limits/scripts/voice.js" $ARGUMENTS`
+and read the answer back verbatim - especially the kept lines, which are the
+only raw text stored.
+
+- (no arguments) - what it knows, how many prompts it has seen, and where the
+  file is.
+- `card` - the exact text that gets injected when the plugin writes as you.
+- `set "<instruction>"` - tell the agent how you want to be talked to. This is
+  the other half: it goes in front of every prompt, it wins over anything
+  learned, and it is the thing to use for "be blunt", "no preamble", "explain
+  like I already know the codebase".
+- `clear` - drop that instruction and go back to the learned traits alone.
+- `off` / `on` - stop or resume learning. `off` keeps what it has.
+- `forget` - delete the profile entirely.
+
+It says nothing until it has seen a dozen prompts, and calls itself provisional
+until fifty; short-text style measurements below that are noise, and it should
+not pretend otherwise.
+
+Report the answer and stop. Do not start other work as part of this command.

package/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "Tells Claude how much usage budget is left: once before each prompt, and again during long turns so the figure it is working from does not go stale. Tells you what each reply and each session cost, after the reply and when the session closes.",
+  "description": "Tells Claude how much usage budget is left: once before each prompt, and again during long turns so the figure it is working from does not go stale. Tells you what each reply and each session cost, after the reply and when the session closes. Says the number once more right before a Workflow or Agent call, because the agents it spawns spend the same window and nothing can speak again until they stop.",
   "hooks": {
     "Stop": [
       {
@@ -44,6 +44,29 @@
           }
         ]
       }
+    ],
+    "SubagentStop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/skills/usage-limits/scripts/pulse.js\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Workflow|Agent|Task",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/skills/usage-limits/scripts/pulse.js\"",
+            "timeout": 10
+          }
+        ]
+      }
     ]
   }
 }

package/package.json

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

@@ -389,6 +389,82 @@ afternoon, so there is no longer anything to buy by winding down.
 The one thing not to economise on is the handoff itself. Everything else can be
 picked up next session; a session that ends without one cannot.
 
+## 6. The relay: when the handoff picks itself up
+
+If a relay is armed, the budget line says so, and the shape of the last hour
+changes. The handoff stops being a note for a person to find and becomes the
+prompt this conversation will be handed back a few minutes after the window
+reopens. So do not wind down, do not narrow the request, and do not stop to
+ask whether to carry on — write the continuation properly and keep working
+until the window actually ends.
+
+Write it with:
+
+```
+node "$CLAUDE_PLUGIN_ROOT/skills/usage-limits/scripts/relay.js" note "<text>"
+```
+
+Write it to be **acted on**, not read: what is done, what is next in order,
+which files are mid-change, what must be verified before anything is built on
+it. It is delivered as a prompt, so an instruction beats a summary. If nothing
+is written, the relay falls back to the outstanding todo list, which is worse.
+
+The relay is off unless the user turned it on, and it only arms while there is
+an unfinished todo list or an approved plan to carry. Do not turn it on for
+them, and do not promise behaviour it does not have:
+
+- It **cannot** type into a terminal or an editor. Computer Use refuses to send
+  input to a shell on purpose; the relay uses it only to tell whether somebody
+  is at the keyboard, and to show a banner.
+- In `notify` mode — the default — it raises a notification and starts nothing.
+- In `resume` mode it runs the CLI itself. A headless resume does **not**
+  inherit the session's permission mode, so unless one was set the resumed run
+  will sit waiting for an approval nobody is there to give.
+- Claude Code's own `autoContinueAtUsageLimit` is better wherever it applies,
+  because the process never dies. It does not apply to `-p` runs, background
+  sessions, or a terminal that has been closed.
+
+`node scripts/relay.js` with no arguments reports all of it.
+
+## Voice
+
+The plugin keeps a small local profile of how the user writes — counters, plus
+at most two short lines of their own text — so that anything written *as* them
+sounds like them. It costs no model call and never leaves the machine.
+
+Two separate things live there and they are not the same:
+
+- The **learned traits** are for writing as the user. Today that is the relay
+  prompt. Do not imitate them in your own replies.
+- The **instruction** they typed at `/usage-limits:voice set` is how they want
+  to be talked to. It appears in the budget line and it applies to you.
+
+If asked what it knows, run `node scripts/voice.js` and read it back verbatim,
+including the kept lines. `forget` deletes it outright.
+
+## Codex, seen from Claude Code
+
+When Codex is installed on the same machine, every display shows its meter
+underneath Claude's: the panel, the status line, the budget line before each
+prompt, the VS Code view and `check`. It is read from the rollouts Codex has
+already written — no child process, no network, and nothing at all if Codex is
+not installed.
+
+**It counts the other way, and that is not a bug.** Codex writes what it has
+*spent* but shows what is *left*: its own status card prints "82% left" where
+Claude Code prints "62% used". So the Codex rows report what remains, their
+bars drain as they are spent where Claude's fill, and every figure carries the
+word "left" so the two can never be read as the same kind of number. The
+colours turn at the same real moment either way — 80% used is 20% left is
+yellow, 90% used is 10% left is red.
+
+There is no mark beside it, only the word "Codex" in OpenAI's green. Codex has
+no mark of its own — it uses OpenAI's Blossom, and there is no Blossom codepoint
+in Unicode, so a terminal cannot draw one. The nearest rosette is a flower, and
+a flower in the slot where a logo should be is not the logo; the word is
+unambiguous and cannot come out as something else in a font that has never heard
+of it.
+
 ## Running under Codex
 
 Everything above works the same. The numbers come from a different place and
@@ -410,11 +486,14 @@ happened to write. It starts a short-lived `codex app-server`, takes about a
 second, and is the Codex equivalent of running `/usage` in Claude Code. Use it
 when the report says the snapshot is old, not routinely.
 
-The difference that matters: **there is no budget line in front of the prompt.**
-Claude Code lets a plugin ship hooks, so it gets one automatically. Codex will
-not load hooks from a plugin, and on current builds it does not run them from
-`~/.codex/hooks.json` or `config.toml` either, so nothing puts the figures in
-front of you before you start.
+The difference that matters: **the budget line is not automatic until you say
+so.** Claude Code lets a plugin ship hooks, so it gets one on install. Codex
+does not load hooks from a plugin (`plugin_hooks` is a removed feature), and it
+runs the ones in `~/.codex/hooks.json` only after a one-time review it shows
+when `codex` starts in a terminal: "Hooks need review - Trust all and
+continue". The desktop app never shows that review, so a machine using only
+the app can have the hooks installed for weeks and never run them once.
+`install-codex-hook.js status` says whether they have ever run.
 
 What replaces it is an instruction, installed by:
 
@@ -437,6 +516,45 @@ say and there is no dollar figure to attach. `scripts/lowpower.js` is for Claude
 Code only: it writes Claude's `settings.json`, so it must not be run under
 Codex. Change model or effort through Codex's own controls instead.
 
+### The effort setting is the thing that empties the window
+
+On Codex this matters more than anywhere else, because the reasoning effort is
+set in `~/.codex/config.toml` and then applies to everything until it is
+changed:
+
+```toml
+model = "gpt-6-astra"
+model_reasoning_effort = "ultra"
+```
+
+A percentage and a turn count do not warn you about that, and it is the single
+most common way an allowance disappears. The headroom figure is built from what
+a turn has cost *on average*, and the average is dominated by whatever effort
+you were running last week. Move to a dearer one and every estimate is too
+generous until enough expensive turns have landed to drag the average up — and
+on a five-hour window on Plus there is no "enough", because the window is gone
+first. One ordinary task at `ultra` on Astra can take the lot while the report
+still says there is room.
+
+So the report measures each effort separately and prices the window at the one
+actually set. Two things surface it:
+
+- `node scripts/usage.js --host codex` prints **what each effort costs,
+  measured on this machine** — turns, output written per turn, and a `*` on the
+  one in force.
+- When the current effort is materially dearer than a cheaper one on record,
+  the budget line says so outright, with what the window really holds at this
+  setting rather than at the blend.
+
+The comparison is on **output tokens per turn**, not cost per turn. Cost per
+turn mostly tracks how big the context happened to be — measured that way,
+`low` turns on a huge context can look dearer than `ultra` ones on a short one,
+which is exactly backwards. Output is the part the effort setting controls.
+
+Act on it the same way as everything else here: keep the high effort where the
+work genuinely needs the thinking, and drop it where it does not. It changes
+what every turn costs, not how many turns you get.
+
 ## When to skip this skill
 
 Do not run the report on every prompt. Once at the start of a long piece of
@@ -471,4 +589,11 @@ stop.
 | `scripts/feed.js` | The status line command Claude Code runs. Not meant to be called by hand. |
 | `scripts/live.js` | The usage reading itself, taken the way Claude Code takes it for `/usage`, kept in `usage-limits-live.json` where `collect()` prefers it when newer than the cache. |
 | `scripts/view.js`, `scripts/bars.js`, `scripts/activity.js` | The display model, the drawing in Claude's colours, and the working/idle marks the hooks leave for the panel. Not meant to be called by hand. |
+| `scripts/relay.js` | The relay: `status`, `on`/`off`, `at N`, `grace N`, `mode notify\|resume`, `permission MODE`, `thinking off\|resume\|always`, `note "<text>"`, `cancel`, `log`. |
+| `scripts/wake.js` | What the scheduler runs after the reset: re-checks the meter, then notifies or resumes. Never called by hand. |
+| `scripts/voice.js` | The local writing profile: `show`, `card`, `set "<instruction>"`, `clear`, `off`/`on`, `forget`. |
 | `references/how-it-works.md` | Where the numbers come from and where they are soft. |
+
+## Codex controls
+
+Under Codex, use `node scripts/lowpower.js on --host codex --effort low` to save defaults for new sessions, optionally adding `--model <supported-model-id>`. `off --host codex` restores them; `--dry-run` previews them. These writes cannot change an active task. Use host controls for its current model and effort; do not prescribe Claude models or /effort in Codex. Headroom is an estimate shared with other account activity, not reserved capacity.

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

@@ -34,6 +34,13 @@ const THEME = {
   permission: [177, 185, 249],
   ultra: [175, 135, 255],
   ultraShimmer: [208, 180, 255],
+  // The Codex row's mark, in the green OpenAI's own products have used, chosen
+  // because it sits at the same visual weight as Claude's orange rather than
+  // shouting over it: relative luminance 0.278 against Claude's 0.283, and a
+  // hue about 148 degrees away, so the two marks read as a pair on one line
+  // and neither one wins. The shimmer is the same lift the Claude one gets.
+  codex: [16, 163, 127],
+  codexShimmer: [36, 203, 167],
   rainbow: [
     [235, 95, 87],
     [245, 139, 87],
@@ -73,6 +80,35 @@ const EMPTY = '░';
 const FILL_ASCII = '#';
 const EMPTY_ASCII = '-';
 
+// Claude Code's own six-pointed asterisk, in the two forms.
+const CLAUDE_MARK = '✻';
+const CLAUDE_MARK_ASCII = '*';
+
+// Codex is labelled with its name, not a mark.
+//
+// It has no mark of its own: it uses OpenAI's Blossom, and there is no Blossom
+// codepoint in Unicode, so a terminal cannot draw one. The nearest rosette is
+// a flower, and a flower standing in for a logo is not the logo - it is a
+// different picture in the same slot, which is worse than no picture at all.
+// The word is unambiguous, costs five columns, and cannot come out as
+// something else in a font that has never heard of it.
+const CODEX_LABEL = 'Codex';
+
+// Claude's mark, in the two forms, so the status line, the panel and the VS
+// Code view cannot end up drawing different ones.
+function mark(options) {
+  const opts = options || {};
+  return opts.ascii ? CLAUDE_MARK_ASCII : CLAUDE_MARK;
+}
+
+function markColour(which) {
+  return which === 'codex' ? THEME.codex : THEME.claude;
+}
+
+function markShimmer(which) {
+  return which === 'codex' ? THEME.codexShimmer : THEME.claudeShimmer;
+}
+
 const DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
 
 function level(percent) {
@@ -82,6 +118,19 @@ function level(percent) {
   return 'fill';
 }
 
+// The same two thresholds, read from the other end.
+//
+// Codex counts down: it reports what is LEFT, and its own status card says
+// "82% left" where Claude Code says "62% used". So the Codex rows are drawn
+// draining rather than filling, and the colours have to turn at the same real
+// moment: 80 percent used is 20 percent left, and 90 used is 10 left.
+function levelLeft(percentLeft) {
+  if (!Number.isFinite(percentLeft)) return 'fill';
+  if (percentLeft <= 100 - DANGER_AT) return 'error';
+  if (percentLeft <= 100 - WARN_AT) return 'warning';
+  return 'fill';
+}
+
 function levelColour(name) {
   if (name === 'error') return THEME.error;
   if (name === 'warning') return THEME.warning;
@@ -333,7 +382,14 @@ module.exports = {
   SPINNER,
   FRAMES,
   level,
+  levelLeft,
   levelColour,
+  CLAUDE_MARK,
+  CLAUDE_MARK_ASCII,
+  CODEX_LABEL,
+  mark,
+  markColour,
+  markShimmer,
   colourMode,
   to256,
   paint,