claude-usage-limits 1.11.5 → 1.11.6

package/.claude-plugin/plugin.json

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

@@ -864,7 +864,7 @@ test/                             node --test, no dependencies
 node --test
 ```
 
-477 tests over the pricing, the window arithmetic, plan and credit detection,
+480 tests over the pricing, the window arithmetic, plan and credit detection,
 the status line, the before-prompt line, the mid-turn pulse, the after-reply tally and the session history, job forecasting,
 per-project attribution, the Codex reader and its installer, the CLI,
 packaging, and the settings save/restore.

package/package.json

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

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

@@ -63,6 +63,7 @@ function mark(state, sessionId, extra, now) {
       // The keyword is per prompt, so a Stop keeps what the prompt said and the
       // next prompt says again.
       ultracode: extra && typeof extra.ultracode === 'boolean' ? extra.ultracode : Boolean(previous.ultracode),
+      ultrathink: extra && typeof extra.ultrathink === 'boolean' ? extra.ultrathink : Boolean(previous.ultrathink),
     };
     if (extra && extra.model) entry.model = String(extra.model);
     else if (previous.model) entry.model = previous.model;
@@ -107,6 +108,7 @@ function summarise(all, now) {
   return {
     working: Boolean(working),
     ultracode: Boolean(working ? working.ultracode : newest && newest.ultracode),
+    ultrathink: Boolean(working ? working.ultrathink : newest && newest.ultrathink),
     model: (working && working.model) || (newest && newest.model) || null,
     at: newest ? newest.at : null,
   };
@@ -134,6 +136,7 @@ function combine(sources, now, windowMs) {
         state: 'idle',
         stateAt: null,
         ultracode: false,
+        ultrathink: false,
         model: null,
         modelName: null,
         effort: null,
@@ -156,6 +159,7 @@ function combine(sources, now, windowMs) {
     row.stateAt = m.at;
     row.state = m.state === 'working' && at - m.at <= within ? 'working' : 'idle';
     row.ultracode = Boolean(m.ultracode);
+    row.ultrathink = Boolean(m.ultrathink);
     if (m.model && !row.model) row.model = m.model;
   }
   for (const id of Object.keys(src.feed || {})) {

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

@@ -166,10 +166,18 @@ function bar(percent, width, options) {
   const fillGlyph = opts.ascii ? FILL_ASCII : FILL;
   const emptyGlyph = opts.ascii ? EMPTY_ASCII : EMPTY;
   const mode = opts.mode || 'none';
-  return (
-    paint(fillGlyph.repeat(filled), levelColour(opts.level || level(pct)), mode) +
-    paint(emptyGlyph.repeat(cells - filled), THEME.empty, mode)
-  );
+  // The filled cells: one colour for the level, or under ultracode the
+  // rainbow sliding along the bar, or under ultrathink the purple with a
+  // moving highlight, the way Claude Code paints those two words.
+  let fill;
+  if (opts.style === 'rainbow' && mode !== 'none') {
+    fill = rainbow(fillGlyph.repeat(filled), opts.tick, { mode, reduced: opts.reduced });
+  } else if (opts.style === 'ultra' && mode !== 'none') {
+    fill = shimmer(fillGlyph.repeat(filled), opts.tick, THEME.ultra, THEME.ultraShimmer, { mode, reduced: opts.reduced });
+  } else {
+    fill = paint(fillGlyph.repeat(filled), levelColour(opts.level || level(pct)), mode);
+  }
+  return fill + paint(emptyGlyph.repeat(cells - filled), THEME.empty, mode);
 }
 
 function spinner(tick, options) {
@@ -231,8 +239,11 @@ function effortColour(name) {
       return { rgb: THEME.permission, shimmer: null, rainbow: false };
     case 'xhigh':
       return { rgb: THEME.ultra, shimmer: THEME.ultraShimmer, rainbow: false };
-    case 'max':
+    // Claude Code's effort picker paints Ultracode in the purple; max is the
+    // one it animates in the rainbow.
     case 'ultracode':
+      return { rgb: THEME.ultra, shimmer: THEME.ultraShimmer, rainbow: false };
+    case 'max':
       return { rgb: THEME.ultra, shimmer: THEME.ultraShimmer, rainbow: true };
     default:
       return { rgb: THEME.inactive, shimmer: null, rainbow: false };

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

@@ -621,8 +621,12 @@ async function run(now, hookInput) {
     'working',
     sessionId,
     {
-      ultracode: Boolean(
-        hookInput && typeof hookInput.prompt === 'string' && /\bultracode\b/i.test(hookInput.prompt)
+      // Only ultrathink, and only as a whole word: it is a real directive in
+      // the prompt. Ultracode is an effort level, read from the setting the
+      // agent reports, never from the text - the word turns up in ordinary
+      // requests, and these marks are read by every panel on the machine.
+      ultrathink: Boolean(
+        hookInput && typeof hookInput.prompt === 'string' && /\bultrathink\b/i.test(hookInput.prompt)
       ),
     },
     now
@@ -635,8 +639,17 @@ async function run(now, hookInput) {
   // one on disk is older than a few minutes. Offline or signed out this is
   // one quick failure and then a widening backoff, never a wait on every
   // prompt; USAGE_LIMITS_FETCH=off turns it off.
-  if (!usage.isCodex()) {
-    try {
+  try {
+    if (usage.isCodex()) {
+      // Codex only writes its meter when it makes a request, so between turns
+      // the newest figure can be half an hour old. Ask it, the way /status
+      // does, when the reading has aged.
+      await require('./codex.js').refreshIfStale({
+        now,
+        maxAgeMs: config.refreshSeconds * SECOND,
+        timeoutMs: REFRESH_TIMEOUT_MS,
+      });
+    } else {
       const cached = usage.collect(now);
       await live.refreshIfStale({
         now,
@@ -645,9 +658,9 @@ async function run(now, hookInput) {
         accountUuid: usage.accountUuid(),
         timeoutMs: REFRESH_TIMEOUT_MS,
       });
-    } catch (err) {
-      // The reading on disk is still there.
     }
+  } catch (err) {
+    // The reading on disk is still there.
   }
   const base = usage.collect(now);
   if (!base.utilization) return '';

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

@@ -628,8 +628,109 @@ function meterFromDisk() {
   return null;
 }
 
+// Where a live reading taken by refreshIfStale() is kept, so the hooks and the
+// report see it without asking Codex again.
+function liveFile() {
+  return path.join(homeDir(), 'usage-limits-codex-live.json');
+}
+
+function readLiveMeter() {
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(liveFile(), 'utf8'));
+  } catch (err) {
+    return null;
+  }
+  if (!parsed || typeof parsed !== 'object') return null;
+  if (!Number.isFinite(parsed.at) || !parsed.meter || typeof parsed.meter !== 'object') return null;
+  return parsed;
+}
+
+function writeLiveMeter(reading) {
+  try {
+    const file = liveFile();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = file + '.' + process.pid + '.usage-limits-tmp';
+    fs.writeFileSync(temp, JSON.stringify(reading), 'utf8');
+    fs.renameSync(temp, file);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+function attemptFile() {
+  return path.join(homeDir(), 'usage-limits-codex-fetch.json');
+}
+
+// Ask Codex for the meter, but only when the newest reading on disk has aged,
+// and never twice in quick succession. Codex writes its meter into a rollout
+// only when it makes a request, so between turns the newest reading can be
+// half an hour old: the agent then plans against a figure from before the work
+// it just did, says the limit is fine, and hits it. This is what closes that
+// gap, the same way the Claude side takes a fresh /usage reading.
+async function refreshIfStale(options) {
+  const opts = options || {};
+  const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+  const maxAgeMs = Number.isFinite(opts.maxAgeMs) ? opts.maxAgeMs : 3 * MINUTE;
+  const env = opts.env || process.env;
+  if (opts.fetch === false || String(env.USAGE_LIMITS_FETCH || '').toLowerCase() === 'off') {
+    return { reading: readLiveMeter(), skipped: 'disabled' };
+  }
+
+  const onDisk = meterFromDisk();
+  const live = readLiveMeter();
+  const newestAt = Math.max(onDisk && Number.isFinite(onDisk.at) ? onDisk.at : 0, live ? live.at : 0);
+  if (newestAt > 0 && now - newestAt < maxAgeMs) return { reading: live, skipped: 'fresh' };
+
+  let attempt = null;
+  try {
+    attempt = JSON.parse(fs.readFileSync(attemptFile(), 'utf8'));
+  } catch (err) {
+    attempt = null;
+  }
+  const sinceAttempt = attempt && Number.isFinite(attempt.attemptedAtMs) ? now - attempt.attemptedAtMs : null;
+  if (sinceAttempt !== null && Number.isFinite(attempt.delayMs) && sinceAttempt >= -MINUTE && sinceAttempt < attempt.delayMs) {
+    return { reading: live, skipped: 'backoff' };
+  }
+  // Claim the attempt before making it: Codex's app-server takes about a
+  // second, and several hooks can fire at once.
+  const claim = (delayMs, kind) => {
+    try {
+      fs.writeFileSync(attemptFile(), JSON.stringify({ attemptedAtMs: now, delayMs, kind }), 'utf8');
+    } catch (err) {
+      // One extra attempt is survivable.
+    }
+  };
+  claim(Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : 8000, 'inflight');
+
+  try {
+    const reading = await refresh({ codexPath: opts.codexPath, timeoutMs: opts.timeoutMs });
+    if (!reading || !reading.meter) {
+      claim(maxAgeMs, 'empty');
+      return { reading: live, skipped: null, error: 'no meter' };
+    }
+    writeLiveMeter(reading);
+    claim(maxAgeMs, 'ok');
+    return { reading, skipped: null };
+  } catch (err) {
+    // Codex missing or not answering: back off rather than pay for it again on
+    // every prompt.
+    claim(Math.min(10 * MINUTE, Math.max(2 * MINUTE, maxAgeMs * 2)), (err && err.code) || 'error');
+    return { reading: live, skipped: null, error: (err && err.code) || 'error' };
+  }
+}
+
 function collect(now, options) {
-  const found = (options && options.meter) || meterFromDisk();
+  // The newest of the three: a reading handed in, one taken by the hooks, or
+  // the newest one Codex happened to write into a rollout.
+  const given = options && options.meter;
+  const live = readLiveMeter();
+  const disk = meterFromDisk();
+  const best =
+    given ||
+    (live && (!disk || !Number.isFinite(disk.at) || live.at > disk.at) ? live : disk);
+  const found = best;
   const mapped = found ? utilizationFrom(found.meter) : null;
   const plan = planFrom(mapped && mapped.planType);
 
@@ -847,6 +948,11 @@ module.exports = {
   planFrom,
   latestMeter,
   meterFromDisk,
+  liveFile,
+  attemptFile,
+  readLiveMeter,
+  writeLiveMeter,
+  refreshIfStale,
   calibrate,
   MIN_POINTS_MOVED,
   MIN_SAMPLE_TURNS,

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

@@ -34,6 +34,9 @@ const WORKING_GAP_MS = 4000;
 // A previous status line gets this long, then we go on without it.
 const CHAIN_TIMEOUT_MS = 2000;
 const STDIN_WAIT_MS = 500;
+// How long a display keeps describing the session it chose before it will
+// follow a different one.
+const STICKY_QUIET_MS = 5 * 60 * 1000;
 // Claude Code draws the status line inside its own margins, a few columns
 // narrower than COLUMNS, and clips what does not fit.
 const STATUSLINE_MARGIN = 4;
@@ -86,8 +89,10 @@ function gapMeansWorking(settings) {
 // spin this one's line.
 function ownState(marks, sessionId, now) {
   const mine = sessionId && marks ? marks[sessionId] : null;
-  if (!mine || !Number.isFinite(mine.at) || now - mine.at > activity.STALE_MS) return { working: false, ultracode: false };
-  return { working: mine.state === 'working', ultracode: Boolean(mine.ultracode) };
+  if (!mine || !Number.isFinite(mine.at) || now - mine.at > activity.STALE_MS) {
+    return { working: false, ultracode: false, ultrathink: false };
+  }
+  return { working: mine.state === 'working', ultracode: Boolean(mine.ultracode), ultrathink: Boolean(mine.ultrathink) };
 }
 
 function number(value) {
@@ -141,6 +146,22 @@ function newest(all) {
   return best;
 }
 
+// Which session a display with no session of its own should describe.
+//
+// "Whichever moved last" reads badly with two windows open: two Claudes on the
+// same model at different efforts made the line flip between ultracode and
+// xhigh every few seconds, which is noise, not news. So a display sticks to
+// the session it is already describing until that one has been quiet for a
+// while, and only then moves to the newest.
+function stickySlot(all, previousId, now, quietMs) {
+  const slots = all || {};
+  const quiet = Number.isFinite(quietMs) ? quietMs : STICKY_QUIET_MS;
+  const at = Number.isFinite(now) ? now : Date.now();
+  const held = previousId ? slots[previousId] : null;
+  if (held && Number.isFinite(held.at) && at - held.at <= quiet) return held;
+  return newest(slots);
+}
+
 function isWorking(slot, now) {
   if (!slot || !Number.isFinite(slot.at) || !Number.isFinite(slot.prevAt)) return false;
   return now - slot.at < WORKING_GAP_MS && slot.at - slot.prevAt < WORKING_GAP_MS;
@@ -166,13 +187,9 @@ function line(built, options) {
   if (built.state === 'none') return bars.dim('usage: no reading yet', mode);
 
   const glyph = built.working
-    ? built.ultracode
-      ? bars.rainbow(bars.spinner(tick, { ascii, reduced }), tick, { mode, reduced })
-      : bars.paint(bars.spinner(tick, { ascii, reduced }), bars.THEME.claude, mode)
+    ? bars.paint(bars.spinner(tick, { ascii, reduced }), bars.THEME.claude, mode)
     : bars.paint(ascii ? '*' : '✻', bars.THEME.claude, mode);
-  // Ultracode is xhigh plus workflows, and Claude names it as its own level in
-  // the picker, so it is named here too, in the rainbow the picker uses.
-  const effortName = built.ultracode ? 'ultracode' : built.effort;
+  const effortName = built.effort;
   const effort = effortName ? bars.effortColour(effortName) : null;
   const effortText = !effortName
     ? ''
@@ -187,7 +204,7 @@ function line(built, options) {
     const label = shortLabel(row, shorter);
     const percent = row.level === 'fill' ? row.percentText : bars.paint(row.percentText, bars.levelColour(row.level), mode);
     if (!width || row.percent === null) return label + ' ' + percent;
-    return label + ' ' + bars.bar(row.percent, width, { mode, level: row.level, ascii }) + ' ' + percent;
+    return label + ' ' + bars.bar(row.percent, width, { mode, level: row.level, ascii, tick, reduced, style: built.style }) + ' ' + percent;
   };
 
   const attempts = [
@@ -346,7 +363,7 @@ async function main(argv) {
       modelName: slot ? slot.modelName : null,
       effort: slot ? slot.effort : null,
       working: own.working || (gapMeansWorking(settings) && isWorking(slot, now)),
-      ultracode: own.ultracode || settings.ultracode === true,
+      ultrathink: Boolean(own.ultrathink),
       settingsModel: collected.settings ? collected.settings.model : null,
       env,
     });
@@ -379,6 +396,8 @@ module.exports = {
   record,
   newest,
   isWorking,
+  stickySlot,
+  STICKY_QUIET_MS,
   gapMeansWorking,
   ownState,
   line,

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

@@ -154,7 +154,9 @@ async function snapshot(options) {
   }
 
   const slots = onCodex ? {} : feed.readFeed();
-  const slot = feed.newest(slots);
+  // Stay with the session already being described, so two windows on the same
+  // model at different efforts do not make the header flip back and forth.
+  const slot = feed.stickySlot(slots, opts.sessionId, now);
   const seen = onCodex ? { working: codexWorking(now), ultracode: false, model: null } : activity.summarise(activity.read(), now);
   const settings = onCodex ? {} : settingsFor();
 
@@ -168,14 +170,24 @@ async function snapshot(options) {
     headersAt: slot ? slot.headersAt : null,
     model: (slot && slot.model) || seen.model || null,
     modelName: slot ? slot.modelName : null,
-    effort: slot ? slot.effort : (onCodex && collected.settings && collected.settings.effortLevel !== 'default' ? collected.settings.effortLevel : null),
+    // The status line is told the effort by Claude Code itself; the setting is
+    // the fallback, and it is what says "ultracode" when no status line is
+    // installed.
+    effort:
+      (slot && slot.effort) ||
+      (collected.settings && collected.settings.effortLevel && collected.settings.effortLevel !== 'default'
+        ? collected.settings.effortLevel
+        : null),
     working: seen.working || feed.isWorking(slot, now),
-    ultracode: seen.ultracode || settings.ultracode === true,
+    // Ultracode comes from the effort level above, not from here. Ultrathink
+    // is a word in a prompt, and the hooks record it per session.
+    ultrathink: Boolean(seen.ultrathink),
     settingsModel: collected.settings ? collected.settings.model : null,
     outcome,
     env,
   });
   built.now = now;
+  built.sessionId = slot && slot.sessionId ? slot.sessionId : null;
   built.host = onCodex ? 'codex' : 'claude';
   built.title = onCodex ? 'Codex usage' : TITLE;
   built.plan = collected.plan || null;
@@ -353,19 +365,17 @@ function render(built, options) {
   const barWidth = Math.max(8, Math.min(50, columns - 6));
   const animate = built.working && !reduced;
 
+  // The title is Claude's orange, shimmering while Claude works, and nothing
+  // else: the rainbow and the purple belong to the bars.
   const glyph = built.working
-    ? built.ultracode
-      ? bars.rainbow(bars.spinner(tick, { ascii, reduced }), tick, { mode, reduced })
-      : bars.paint(bars.spinner(tick, { ascii, reduced }), bars.THEME.claude, mode)
+    ? bars.paint(bars.spinner(tick, { ascii, reduced }), bars.THEME.claude, mode)
     : bars.paint(ascii ? '*' : '✻', bars.THEME.claude, mode);
   const titleText = built.title || TITLE;
-  const title = built.ultracode
-    ? bars.rainbow(titleText, tick, { mode, reduced })
-    : animate
-      ? bars.shimmer(titleText, tick, bars.THEME.claude, bars.THEME.claudeShimmer, { mode, reduced })
-      : bars.paint(titleText, bars.THEME.claude, mode);
+  const title = animate
+    ? bars.shimmer(titleText, tick, bars.THEME.claude, bars.THEME.claudeShimmer, { mode, reduced })
+    : bars.paint(titleText, bars.THEME.claude, mode);
 
-  const effortName = built.ultracode ? 'ultracode' : built.effort;
+  const effortName = built.effort;
   const effort = effortName ? bars.effortColour(effortName) : null;
   const effortText = !effortName
     ? ''
@@ -375,7 +385,10 @@ function render(built, options) {
         ? bars.shimmer(effortName, tick, effort.rgb, effort.shimmer, { mode, reduced })
         : bars.paint(effortName, effort.rgb, mode);
   const status = built.working ? 'working' : 'idle';
-  const who = [built.modelLabel, effortText, bars.dim(status, mode)].filter(Boolean).join(bars.dim(' · ', mode));
+  const thinking = built.ultrathink
+    ? bars.rainbow('ultrathink', tick, { mode, reduced })
+    : '';
+  const who = [built.modelLabel, effortText, thinking, bars.dim(status, mode)].filter(Boolean).join(bars.dim(' · ', mode));
 
   const head = [glyph + ' ' + bars.bold(title, mode), who];
   const body = [];
@@ -385,7 +398,9 @@ function render(built, options) {
     body.push({
       lines: [
         bars.bold(columns < 34 ? shortTitle(row) : row.title, mode),
-        (row.percent === null ? bars.paint((ascii ? '-' : '░').repeat(barWidth), bars.THEME.empty, mode) : bars.bar(row.percent, barWidth, { mode, level: row.level, ascii })) +
+        (row.percent === null
+          ? bars.paint((ascii ? '-' : '░').repeat(barWidth), bars.THEME.empty, mode)
+          : bars.bar(row.percent, barWidth, { mode, level: row.level, ascii, tick, reduced, style: built.style })) +
           ' ' +
           percent,
         subline(row, mode, { now, clock }),
@@ -687,7 +702,7 @@ async function interactive(args) {
       // The reading runs beside the frames, never in front of them: a slow
       // network must not freeze the spinner or the countdown.
       state.fetching = true;
-      snapshot({ fetch: true, network: fetch, env, now })
+      snapshot({ fetch: true, network: fetch, env, now, sessionId: state.built ? state.built.sessionId : null })
         .then((built) => {
           state.built = built;
           state.outcome = built.outcome;
@@ -715,6 +730,7 @@ async function interactive(args) {
           now,
           outcome: state.outcome,
           pace: state.built ? state.built.pace : null,
+          sessionId: state.built ? state.built.sessionId : null,
         });
       } catch (err) {
         // Keep the last frame; a transient read error is not worth a blank.
@@ -734,7 +750,7 @@ async function interactive(args) {
     }
     if (state.built) {
       const tick = Math.floor(Date.now() / bars.TICK_MS);
-      const animating = (state.built.working || state.built.ultracode) && !reduced;
+      const animating = (state.built.working || state.built.ultracode || state.built.ultrathink) && !reduced;
       if (state.dirty || (animating && tick !== state.lastTick) || now - state.lastCheck < FRAME_MS) {
         state.lastTick = tick;
         draw(Date.now());

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

@@ -134,8 +134,10 @@ async function run(now, hookInput) {
   // A reading as old as the interval is replaced with the one Claude Code
   // would take for /usage, so a turn that runs for an hour is measured
   // against the account rather than against a guess from its own transcript.
-  if (!usage.isCodex()) {
-    try {
+  try {
+    if (usage.isCodex()) {
+      await require('./codex.js').refreshIfStale({ now, maxAgeMs: every, timeoutMs: 4000 });
+    } else {
       const cached = usage.collect(now);
       await live.refreshIfStale({
         now,
@@ -144,9 +146,9 @@ async function run(now, hookInput) {
         accountUuid: usage.accountUuid(),
         timeoutMs: 4000,
       });
-    } catch (err) {
-      // The reading on disk is still there.
     }
+  } catch (err) {
+    // The reading on disk is still there.
   }
 
   const data = await usage.report(now, { sessionId });

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

@@ -195,7 +195,21 @@ function build(input) {
   const state = !hasData ? 'none' : ageMs !== null && ageMs < LIVE_AGE_MS ? 'live' : 'cached';
 
   const effort = opts.effort ? String(opts.effort).toLowerCase() : null;
-  const ultracode = Boolean(opts.ultracode) || effort === 'max' || effort === 'ultracode';
+  // Ultracode is a level in Claude Code's own effort picker, painted purple
+  // there, so it comes from the level the agent reports and NEVER from a word
+  // in the prompt. Reading it from the text was wrong twice over: "ultracode"
+  // appears in ordinary requests, and the marks are machine-wide, so one
+  // session mentioning it turned every panel purple while the effort was
+  // xhigh.
+  const ultracode = effort === 'ultracode';
+  // Ultrathink is a word in the prompt, and Claude Code paints that word in
+  // the rainbow, so the bars do the same.
+  const ultrathink = Boolean(opts.ultrathink);
+  // What the bars do: the rainbow for ultrathink and for max effort, the
+  // purple gradient of the effort picker for ultracode, their own level
+  // colour otherwise. The title is never painted in either; it stays the
+  // Claude orange, because the bar is the thing being reported on.
+  const style = ultrathink || effort === 'max' ? 'rainbow' : ultracode ? 'ultra' : null;
 
   return {
     rows,
@@ -205,6 +219,8 @@ function build(input) {
     modelLabel: opts.modelName || bars.prettyModel(model),
     effort,
     ultracode,
+    ultrathink,
+    style,
     working: Boolean(opts.working),
     state,
     ageMs,