claude-usage-limits 1.9.2 → 1.11.2

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

@@ -0,0 +1,198 @@
+'use strict';
+
+// Whether Claude is working right now, as told by the hooks that already run.
+//
+// The panel wants to animate while Claude works and sit still while it waits,
+// and the hooks are the cheapest honest signal there is: the prompt hook
+// fires when a turn starts, the tool hook fires after every tool call, and the
+// Stop hook fires when the reply is done. Each one writes a few bytes here.
+//
+// One slot per session, because two windows can be in different states at
+// once and a Stop in one must not make the other look idle.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const KEEP_SESSIONS = 8;
+// A session that has said nothing for this long is not working, whatever its
+// last word was: a crash never sends Stop.
+const STALE_MS = 15 * 60 * 1000;
+
+function configDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+}
+
+function activityFile() {
+  return path.join(configDir(), 'usage-limits-activity.json');
+}
+
+function read() {
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(activityFile(), 'utf8'));
+  } catch (err) {
+    return {};
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
+  const slots = {};
+  for (const key of Object.keys(parsed)) {
+    const value = parsed[key];
+    if (value && typeof value === 'object' && Number.isFinite(value.at)) slots[key] = value;
+  }
+  return slots;
+}
+
+function trim(all, keep) {
+  const ordered = Object.keys(all).sort((a, b) => (all[b].at || 0) - (all[a].at || 0));
+  const kept = {};
+  for (const key of ordered.slice(0, keep || KEEP_SESSIONS)) kept[key] = all[key];
+  return kept;
+}
+
+// Record a state for a session. Never throws: this runs inside hooks, and a
+// hook that fails over a status file would be far worse than a panel that
+// animates a little late.
+function mark(state, sessionId, extra, now) {
+  try {
+    const all = read();
+    const previous = all[sessionId || '_'] || {};
+    const entry = {
+      at: Number.isFinite(now) ? now : Date.now(),
+      state: state === 'working' ? 'working' : 'idle',
+      // 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),
+    };
+    if (extra && extra.model) entry.model = String(extra.model);
+    else if (previous.model) entry.model = previous.model;
+    all[sessionId || '_'] = entry;
+    const file = activityFile();
+    const temp = file + '.' + process.pid + '.usage-limits-tmp';
+    try {
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(temp, JSON.stringify(trim(all)), 'utf8');
+      fs.renameSync(temp, file);
+    } catch (err) {
+      // A rename Windows refused leaves nothing behind.
+      try {
+        fs.unlinkSync(temp);
+      } catch (gone) {
+        // Nothing to clean up.
+      }
+      return false;
+    }
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+// The picture across every session: is anything working, and is the most
+// recently active working session in ultracode.
+function summarise(all, now) {
+  const at = Number.isFinite(now) ? now : Date.now();
+  let working = null;
+  let newest = null;
+  for (const key of Object.keys(all || {})) {
+    // A mark with no session id cannot be attributed, so it is nobody's: the
+    // summary and the sessions list must agree about who is working.
+    if (key === '_') continue;
+    const entry = all[key];
+    if (!entry || !Number.isFinite(entry.at)) continue;
+    if (at - entry.at > STALE_MS) continue;
+    if (!newest || entry.at > newest.at) newest = entry;
+    if (entry.state === 'working' && (!working || entry.at > working.at)) working = entry;
+  }
+  return {
+    working: Boolean(working),
+    ultracode: Boolean(working ? working.ultracode : newest && newest.ultracode),
+    model: (working && working.model) || (newest && newest.model) || null,
+    at: newest ? newest.at : null,
+  };
+}
+
+// Every Claude on this machine that has been heard from lately, one row per
+// session, from all the places the plugin hears about them: the hook marks
+// (working or idle), the status line feed (model, effort, directory), the
+// Stop hook's tally (project, cost, turns) and the prompt hook's cache (when
+// it last prompted). A session is listed if any of them saw it within the
+// window; it is "working" only if its own mark says so and is fresh.
+function combine(sources, now, windowMs) {
+  const at = Number.isFinite(now) ? now : Date.now();
+  const within = Number.isFinite(windowMs) ? windowMs : STALE_MS;
+  const src = sources || {};
+  const rows = new Map();
+
+  const touch = (id, seenAt) => {
+    if (!id || id === '_') return null;
+    let row = rows.get(id);
+    if (!row) {
+      row = {
+        sessionId: id,
+        lastAt: 0,
+        state: 'idle',
+        stateAt: null,
+        ultracode: false,
+        model: null,
+        modelName: null,
+        effort: null,
+        cwd: null,
+        project: null,
+        cost: null,
+        turns: null,
+      };
+      rows.set(id, row);
+    }
+    if (Number.isFinite(seenAt) && seenAt > row.lastAt) row.lastAt = seenAt;
+    return row;
+  };
+
+  for (const id of Object.keys(src.marks || {})) {
+    const m = src.marks[id];
+    if (!m || !Number.isFinite(m.at)) continue;
+    const row = touch(id, m.at);
+    if (!row) continue;
+    row.stateAt = m.at;
+    row.state = m.state === 'working' && at - m.at <= within ? 'working' : 'idle';
+    row.ultracode = Boolean(m.ultracode);
+    if (m.model && !row.model) row.model = m.model;
+  }
+  for (const id of Object.keys(src.feed || {})) {
+    const s = src.feed[id];
+    if (!s || !Number.isFinite(s.at)) continue;
+    const row = touch(id, s.at);
+    if (!row) continue;
+    if (s.model) row.model = s.model;
+    if (s.modelName) row.modelName = s.modelName;
+    if (s.effort) row.effort = s.effort;
+    if (s.cwd) row.cwd = s.cwd;
+  }
+  for (const s of Array.isArray(src.tally) ? src.tally : []) {
+    if (!s || !s.sessionId) continue;
+    const row = touch(s.sessionId, s.lastAt);
+    if (!row) continue;
+    if (s.project) row.project = s.project;
+    if (Number.isFinite(s.cost)) row.cost = s.cost;
+    if (Number.isFinite(s.turns)) row.turns = s.turns;
+  }
+  for (const id of Object.keys(src.brief || {})) {
+    const b = src.brief[id];
+    if (b && Number.isFinite(b.at)) touch(id, b.at);
+  }
+
+  return [...rows.values()]
+    .filter((row) => at - row.lastAt <= within)
+    .sort((a, b) => b.lastAt - a.lastAt);
+}
+
+module.exports = {
+  KEEP_SESSIONS,
+  STALE_MS,
+  activityFile,
+  read,
+  mark,
+  trim,
+  summarise,
+  combine,
+};

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

@@ -0,0 +1,340 @@
+'use strict';
+
+// How the numbers are drawn: Claude Code's own colours, its spinner, its
+// shimmer and its rainbow, so a bar from this plugin sits beside the chat
+// without looking like it came from somewhere else.
+//
+// Everything here is a pure function of its arguments. The status line, the
+// side panel and the VS Code view all draw from this one file, which is what
+// keeps the three of them agreeing about what 85 percent looks like.
+//
+// The palette is Claude Code's dark theme, read out of the CLI itself rather
+// than approximated. The names are Claude's: rate_limit_fill is what /usage
+// paints its bars with, claudeShimmer is the highlight that sweeps across
+// "Thinking", and the seven rainbow colours are what "ultrathink" and the
+// max effort setting are painted in.
+
+const usage = require('./usage.js');
+
+const MINUTE = 60 * 1000;
+const HOUR = 60 * MINUTE;
+
+const THEME = {
+  claude: [215, 119, 87],
+  claudeShimmer: [235, 159, 127],
+  fill: [177, 185, 249],
+  empty: [80, 83, 112],
+  warning: [255, 193, 7],
+  warningShimmer: [255, 223, 57],
+  error: [255, 107, 128],
+  success: [78, 186, 101],
+  text: [255, 255, 255],
+  inactive: [153, 153, 153],
+  subtle: [80, 80, 80],
+  permission: [177, 185, 249],
+  ultra: [175, 135, 255],
+  ultraShimmer: [208, 180, 255],
+  rainbow: [
+    [235, 95, 87],
+    [245, 139, 87],
+    [250, 195, 95],
+    [145, 200, 130],
+    [130, 170, 220],
+    [155, 130, 200],
+    [200, 130, 180],
+  ],
+  rainbowShimmer: [
+    [250, 155, 147],
+    [255, 185, 137],
+    [255, 225, 155],
+    [185, 230, 180],
+    [180, 205, 240],
+    [195, 180, 230],
+    [230, 180, 210],
+  ],
+};
+
+// One frame every 150ms is the cadence Claude Code animates at.
+const TICK_MS = 150;
+
+// The two thresholds. A bar is its normal colour below 80, yellow from 80,
+// red from 90. Each window is judged on its own.
+const WARN_AT = 80;
+const DANGER_AT = 90;
+
+// Claude Code's spinner, forward then back again.
+const SPINNER = ['·', '✢', '✳', '✶', '✻', '✽'];
+const SPINNER_ASCII = ['.', '+', '*', 'x', '*', '+'];
+const FRAMES = SPINNER.concat(SPINNER.slice().reverse());
+const FRAMES_ASCII = SPINNER_ASCII.concat(SPINNER_ASCII.slice().reverse());
+
+const FILL = '█';
+const EMPTY = '░';
+const FILL_ASCII = '#';
+const EMPTY_ASCII = '-';
+
+const DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+
+function level(percent) {
+  if (!Number.isFinite(percent)) return 'fill';
+  if (percent >= DANGER_AT) return 'error';
+  if (percent >= WARN_AT) return 'warning';
+  return 'fill';
+}
+
+function levelColour(name) {
+  if (name === 'error') return THEME.error;
+  if (name === 'warning') return THEME.warning;
+  return THEME.fill;
+}
+
+// What the terminal can show. The status line is a special case: Claude Code
+// captures the script's output, so stdout is never a TTY there, yet ANSI is
+// supported. Callers that know that pass isTTY as true.
+function colourMode(env, isTTY) {
+  const e = env || process.env;
+  if (e.NO_COLOR !== undefined && e.NO_COLOR !== '') return 'none';
+  const forced = e.FORCE_COLOR;
+  if (forced !== undefined && forced !== '' && forced !== '0' && forced !== 'false') return 'truecolor';
+  if (isTTY === false) return 'none';
+  if (e.USAGE_LIMITS_COLOUR === '256') return '256';
+  if (e.USAGE_LIMITS_COLOUR === 'none' || e.USAGE_LIMITS_COLOUR === 'off') return 'none';
+  const term = String(e.TERM || '').toLowerCase();
+  if (term === 'dumb') return 'none';
+  const colorterm = String(e.COLORTERM || '').toLowerCase();
+  if (colorterm === 'truecolor' || colorterm === '24bit') return 'truecolor';
+  const program = String(e.TERM_PROGRAM || '').toLowerCase();
+  if (e.WT_SESSION) return 'truecolor';
+  if (['vscode', 'iterm.app', 'wezterm', 'ghostty', 'hyper', 'alacritty', 'kitty'].indexOf(program) !== -1) {
+    return 'truecolor';
+  }
+  return '256';
+}
+
+// Nearest entry in the 6x6x6 cube, or the grey ramp for greys.
+function to256(rgb) {
+  const r = rgb[0];
+  const g = rgb[1];
+  const b = rgb[2];
+  if (r === g && g === b) {
+    if (r < 8) return 16;
+    if (r > 248) return 231;
+    return Math.round(((r - 8) / 247) * 24) + 232;
+  }
+  const step = (v) => Math.round((v / 255) * 5);
+  return 16 + 36 * step(r) + 6 * step(g) + step(b);
+}
+
+function colourCode(rgb, mode) {
+  if (!rgb || mode === 'none' || !mode) return null;
+  if (mode === '256') return '38;5;' + to256(rgb);
+  return '38;2;' + rgb[0] + ';' + rgb[1] + ';' + rgb[2];
+}
+
+function paint(text, rgb, mode) {
+  const code = colourCode(rgb, mode);
+  if (!code || text === '') return String(text);
+  return '\x1b[' + code + 'm' + text + '\x1b[39m';
+}
+
+function dim(text, mode) {
+  if (!mode || mode === 'none' || text === '') return String(text);
+  return '\x1b[2m' + text + '\x1b[22m';
+}
+
+function bold(text, mode) {
+  if (!mode || mode === 'none' || text === '') return String(text);
+  return '\x1b[1m' + text + '\x1b[22m';
+}
+
+function clamp(value, low, high) {
+  return Math.min(high, Math.max(low, value));
+}
+
+// The bar. Rounded to the nearest cell, with two honesty rules: anything
+// spent shows as at least one cell, and anything short of the whole window is
+// never drawn as full. The number beside the bar carries the precision; the
+// bar carries the shape.
+function bar(percent, width, options) {
+  const opts = options || {};
+  const cells = Math.max(0, Math.floor(width || 0));
+  if (!cells) return '';
+  const pct = clamp(Number.isFinite(percent) ? percent : 0, 0, 100);
+  let filled = Math.round((cells * pct) / 100);
+  if (pct > 0 && filled === 0) filled = 1;
+  if (pct < 100 && filled === cells) filled = cells - 1;
+  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)
+  );
+}
+
+function spinner(tick, options) {
+  const opts = options || {};
+  const frames = opts.ascii ? FRAMES_ASCII : FRAMES;
+  if (opts.reduced) return frames[0];
+  const count = frames.length;
+  const index = (((Number.isFinite(tick) ? Math.floor(tick) : 0) % count) + count) % count;
+  return frames[index];
+}
+
+// A three-character highlight that walks along the text and starts again, the
+// way "Thinking" glows in Claude Code. Reduced motion keeps the base colour
+// and drops the walk.
+function shimmer(text, tick, base, highlight, options) {
+  const opts = options || {};
+  const mode = opts.mode || 'none';
+  const chars = Array.from(String(text));
+  if (mode === 'none') return chars.join('');
+  if (opts.reduced || !highlight) return paint(chars.join(''), base, mode);
+  const period = chars.length + 4;
+  const centre = ((((Number.isFinite(tick) ? Math.floor(tick) : 0) % period) + period) % period) - 1;
+  let out = '';
+  for (let i = 0; i < chars.length; i += 1) {
+    out += paint(chars[i], Math.abs(i - centre) <= 1 ? highlight : base, mode);
+  }
+  return out;
+}
+
+// Seven colours sliding along the text, with the brighter variant at the
+// leading edge. This is what Claude Code paints "ultrathink" and the max
+// effort tag with.
+function rainbow(text, tick, options) {
+  const opts = options || {};
+  const mode = opts.mode || 'none';
+  const chars = Array.from(String(text));
+  if (mode === 'none') return chars.join('');
+  const step = opts.reduced ? 0 : Number.isFinite(tick) ? Math.floor(tick) : 0;
+  const count = THEME.rainbow.length;
+  let out = '';
+  for (let i = 0; i < chars.length; i += 1) {
+    const index = ((((i - step) % count) + count) % count);
+    const leading = !opts.reduced && chars.length > 0 && i === (((step % chars.length) + chars.length) % chars.length);
+    out += paint(chars[i], leading ? THEME.rainbowShimmer[index] : THEME.rainbow[index], mode);
+  }
+  return out;
+}
+
+// The colours the /effort picker uses for each level. xhigh gets the purple
+// shimmer, max and ultracode the rainbow.
+function effortColour(name) {
+  const key = String(name || '').toLowerCase();
+  switch (key) {
+    case 'low':
+      return { rgb: THEME.warning, shimmer: null, rainbow: false };
+    case 'medium':
+      return { rgb: THEME.success, shimmer: null, rainbow: false };
+    case 'high':
+      return { rgb: THEME.permission, shimmer: null, rainbow: false };
+    case 'xhigh':
+      return { rgb: THEME.ultra, shimmer: THEME.ultraShimmer, rainbow: false };
+    case 'max':
+    case 'ultracode':
+      return { rgb: THEME.ultra, shimmer: THEME.ultraShimmer, rainbow: true };
+    default:
+      return { rgb: THEME.inactive, shimmer: null, rainbow: false };
+  }
+}
+
+const ANSI = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+
+function stripAnsi(text) {
+  return String(text).replace(ANSI, '');
+}
+
+function visibleWidth(text) {
+  return Array.from(stripAnsi(text)).length;
+}
+
+function clockText(ms, now, options) {
+  const opts = options || {};
+  const date = new Date(ms);
+  const hours = opts.utc ? date.getUTCHours() : date.getHours();
+  const minutes = opts.utc ? date.getUTCMinutes() : date.getMinutes();
+  const day = opts.utc ? date.getUTCDay() : date.getDay();
+  const prefix = ms - now > 24 * HOUR ? DAYS[day] + ' ' : '';
+  const mm = String(minutes).padStart(2, '0');
+  if (opts.clock === '24h') return prefix + String(hours).padStart(2, '0') + ':' + mm;
+  const twelve = hours % 12 || 12;
+  return prefix + twelve + ':' + mm + (hours < 12 ? ' AM' : ' PM');
+}
+
+// "resets in 4h 12m at 4:12 PM". The duration is what you plan against; the
+// clock time is what you tell someone else.
+function formatReset(msToReset, resetsAtMs, now, options) {
+  if (msToReset === null || msToReset === undefined || !Number.isFinite(msToReset)) return '';
+  if (msToReset <= 0) return 'resets now';
+  let text = 'resets in ' + usage.formatDuration(msToReset);
+  if (Number.isFinite(resetsAtMs)) {
+    text += ' at ' + clockText(resetsAtMs, Number.isFinite(now) ? now : Date.now(), options);
+  }
+  return text;
+}
+
+function capitalise(word) {
+  return word ? word.charAt(0).toUpperCase() + word.slice(1) : word;
+}
+
+// "claude-fable-5-1[1m]" -> "Fable 5.1 1M", the way the model picker says it.
+function prettyModel(id) {
+  if (id === null || id === undefined) return 'Unknown model';
+  let name = String(id).trim();
+  if (!name) return 'Unknown model';
+  const lower = name.toLowerCase();
+  if (lower === 'default') return 'Default model';
+  if (lower === 'opusplan') return 'Opus plan';
+  let suffix = '';
+  const bracket = name.match(/\[([^\]]+)\]$/);
+  if (bracket) {
+    suffix = ' ' + bracket[1].toUpperCase();
+    name = name.slice(0, bracket.index);
+  }
+  // OpenAI's names, for the Codex side: "gpt-6-astra" is "GPT-6 Astra",
+  // "gpt-5.6-sol" is "GPT-5.6 Sol", "o4-mini" is "o4 Mini".
+  const gpt = name.match(/^gpt-?(\d+(?:\.\d+)?)(?:-(.+))?$/i);
+  if (gpt) {
+    const rest = gpt[2] ? ' ' + gpt[2].split('-').filter(Boolean).map(capitalise).join(' ') : '';
+    return 'GPT-' + gpt[1] + rest + suffix;
+  }
+  const oSeries = name.match(/^(o\d+)(?:-(.+))?$/i);
+  if (oSeries) {
+    const rest = oSeries[2] ? ' ' + oSeries[2].split('-').filter(Boolean).map(capitalise).join(' ') : '';
+    return oSeries[1].toLowerCase() + rest + suffix;
+  }
+  name = name.replace(/^.*?claude-/, '');
+  name = name.replace(/-v\d+:\d+$/, '');
+  name = name.replace(/-\d{8}$/, '');
+  const parts = name.split('-').filter(Boolean);
+  const words = parts.filter((part) => !/^\d+$/.test(part)).map(capitalise);
+  const numbers = parts.filter((part) => /^\d+$/.test(part));
+  const label = words.join(' ') + (numbers.length ? ' ' + numbers.join('.') : '');
+  return (label.trim() || capitalise(String(id))) + suffix;
+}
+
+module.exports = {
+  THEME,
+  TICK_MS,
+  WARN_AT,
+  DANGER_AT,
+  SPINNER,
+  FRAMES,
+  level,
+  levelColour,
+  colourMode,
+  to256,
+  paint,
+  dim,
+  bold,
+  bar,
+  spinner,
+  shimmer,
+  rainbow,
+  effortColour,
+  stripAnsi,
+  visibleWidth,
+  formatReset,
+  prettyModel,
+};

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

@@ -16,6 +16,8 @@ const path = require('path');
 const usage = require('./usage.js');
 const host = require('./host.js');
 const tally = require('./tally.js');
+const activity = require('./activity.js');
+const live = require('./live.js');
 
 const SECOND = 1000;
 const DAY = 24 * 60 * 60 * 1000;
@@ -50,8 +52,13 @@ const DEFAULTS = {
   // something ambitious" - that judgement belongs to whoever is doing the work,
   // and it needs the number, not an instruction.
   runwayMinutes: 10,
+  // How old the reading may be before the hook takes a fresh one.
+  refreshSeconds: 180,
 };
 
+// A hook has ten seconds; the reading gets four of them at most.
+const REFRESH_TIMEOUT_MS = 4000;
+
 // The runway is worth saying long before it is worth acting on, because it is
 // the figure that stops a turn count from flattering. Two hundred turns sounds
 // like plenty and can be twenty minutes when three sessions are spending.
@@ -181,6 +188,7 @@ function settings() {
     cacheSeconds: number(env.USAGE_LIMITS_CACHE, DEFAULTS.cacheSeconds),
     fewTurns: number(env.USAGE_LIMITS_FEW_TURNS, DEFAULTS.fewTurns),
     runwayMinutes: number(env.USAGE_LIMITS_RUNWAY, DEFAULTS.runwayMinutes),
+    refreshSeconds: number(env.USAGE_LIMITS_REFRESH, DEFAULTS.refreshSeconds),
   };
 }
 
@@ -261,6 +269,7 @@ function pressure(window, now, config, turnsLeft) {
 const CACHED_BINDING_FIELDS = [
   'key',
   'label',
+  'applies',
   'percentUsed',
   'stale',
   'estimated',
@@ -327,11 +336,22 @@ function readHookInput() {
 // Kept as a re-export so there is exactly one implementation.
 const sessionSpend = usage.sessionSpend;
 
+// One is not a plural. The line is read by an agent that then repeats it to
+// the user, so "about 1 points" is a small error that gets copied out loud.
+function count(value, word) {
+  return value + ' ' + word + (Math.abs(value) === 1 ? '' : 's');
+}
+
 function describeWindow(window) {
   if (!window) return null;
   if (window.stale) return window.label + ' rolling over';
   const about = window.estimated || window.adjusted ? ' about ' : ' ';
-  return window.label + about + window.percentUsed + '%';
+  // A per-model weekly for a model this session is not running is listed, but
+  // never bare: 88% beside the other percentages is read as 88% of the budget
+  // in hand, and the reply that follows sizes the work down for a limit not one
+  // turn here can move.
+  const idle = window.applies === false ? " (not this session's model)" : '';
+  return window.label + about + window.percentUsed + '%' + idle;
 }
 
 // Everything except the window that will actually stop the work.
@@ -360,7 +380,7 @@ function briefText(parts) {
         ? ' (' + parts.sessions + ' sessions active, roughly ' + parts.yourTurnsLeft +
           ' of them yours)'
         : '';
-    bound.push('about ' + parts.turnsLeft + ' turns of headroom' + shared);
+    bound.push('about ' + count(parts.turnsLeft, 'turn') + ' of headroom' + shared);
     // A turn count is a poor sense of urgency when several agents are spending
     // at once: two hundred turns sounds like plenty and can be gone in ten
     // minutes. The runway is the figure that does not flatter.
@@ -394,7 +414,7 @@ function briefText(parts) {
     );
   } else if (parts.pointsSinceSnapshot) {
     sentences.push(
-      'That includes about ' + parts.pointsSinceSnapshot + ' points spent since the ' +
+      'That includes about ' + count(parts.pointsSinceSnapshot, 'point') + ' spent since the ' +
         'snapshot was taken ' + parts.snapshotAge + ' ago, which it does not know about yet.'
     );
   } else if (parts.staleWindows) {
@@ -411,8 +431,8 @@ function briefText(parts) {
     // not 82%; it is unknown, with 82% as the floor. Say exactly that.
     sentences.push(
       'That percentage is a floor, not a current reading: the last real snapshot is ' +
-        parts.snapshotAge + ' old and about ' + parts.pointsBeyondSnapshot +
-        ' points have been spent since, more than it said was left. Either the window is ' +
+        parts.snapshotAge + ' old and about ' + count(parts.pointsBeyondSnapshot, 'point') +
+        ' have been spent since, more than it said was left. Either the window is ' +
         'already exhausted or the snapshot is wrong; /usage refreshes it.'
     );
   }
@@ -594,11 +614,44 @@ async function run(now, hookInput) {
   // before any file is read.
   usage.setHost(host.detect(process.argv.slice(2), process.env));
 
+  const sessionId = hookInput && hookInput.session_id ? hookInput.session_id : null;
+  // A prompt has arrived, so this session is working, and the prompt itself
+  // says whether it asked for ultracode. The panel animates from this.
+  activity.mark(
+    'working',
+    sessionId,
+    {
+      ultracode: Boolean(
+        hookInput && typeof hookInput.prompt === 'string' && /\bultracode\b/i.test(hookInput.prompt)
+      ),
+    },
+    now
+  );
+
   const config = settings();
+  // The reading ages during long turns, and a burst of parallel agents can
+  // spend half a window between two of them. Before the numbers go in front
+  // of Claude, take the same reading Claude Code takes for /usage when the
+  // 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 {
+      const cached = usage.collect(now);
+      await live.refreshIfStale({
+        now,
+        maxAgeMs: config.refreshSeconds * SECOND,
+        cacheFetchedAtMs: cached.snapshotFetchedAt,
+        accountUuid: usage.accountUuid(),
+        timeoutMs: REFRESH_TIMEOUT_MS,
+      });
+    } catch (err) {
+      // The reading on disk is still there.
+    }
+  }
   const base = usage.collect(now);
   if (!base.utilization) return '';
 
-  const sessionId = hookInput && hookInput.session_id ? hookInput.session_id : null;
   const all = readCache();
   let view = pickCached(all, sessionId, now, config.cacheSeconds * SECOND);