claude-usage-limits 1.11.7 → 1.13.0

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

@@ -44,6 +44,10 @@ const STATUSLINE_MARGIN = 4;
 const SHORT = { five_hour: 'session', seven_day: 'week', spend_limit: 'spend' };
 // When even that is too wide.
 const SHORTER = { five_hour: '5h', seven_day: 'wk', spend_limit: 'spend' };
+// Codex names its own windows "5h limit" and "Weekly limit"; on one line they
+// are the same two abbreviations Claude's get.
+const SHORT_CODEX = { five_hour: '5h', seven_day: 'week' };
+const SHORTER_CODEX = { five_hour: '5h', seven_day: 'wk' };
 
 function configDir() {
   return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
@@ -198,7 +202,10 @@ function line(built, options) {
       : effort.shimmer && built.working
         ? bars.shimmer(effortName, tick, effort.rgb, effort.shimmer, { mode, reduced })
         : bars.paint(effortName, effort.rgb, mode);
-  const head = glyph + ' ' + built.modelLabel + (effortText ? ' ' + bars.dim('·', mode) + ' ' + effortText : '');
+  // The word, in the rainbow, the way Claude Code paints it in the prompt.
+  const thinking = built.ultrathink ? ' ' + bars.dim('·', mode) + ' ' + bars.rainbow('ultrathink', tick, { mode, reduced }) : '';
+  const head =
+    glyph + ' ' + built.modelLabel + (effortText ? ' ' + bars.dim('·', mode) + ' ' + effortText : '') + thinking;
 
   const segment = (row, width, shorter) => {
     const label = shortLabel(row, shorter);
@@ -218,6 +225,14 @@ function line(built, options) {
     { width: 0, head: false, shorter: true },
     { width: 0, head: false, shorter: true, gap: ' ' },
   ];
+
+  // The Codex tail.
+  //
+  // It always says "left", and if that does not fit it is not shown at all.
+  // Codex reports what remains and Claude reports what is spent, so a bare
+  // "85%" sitting beside a bare "15%" would be read as the same kind of
+  // number when they run in opposite directions - which is precisely the
+  // confusion this row exists to remove.
   // Another Claude spending the same budget is worth a word on the line.
   const others =
     Number.isFinite(built.othersWorking) && built.othersWorking > 0
@@ -234,6 +249,76 @@ function line(built, options) {
   return text;
 }
 
+// The Codex line, drawn UNDERNEATH the Claude one.
+//
+// It began as a tail on the same line, and that was wrong twice over. It read
+// as one more Claude window when it is a different account with a different
+// budget, and being last it was the first thing the width ladder dropped, so on
+// an ordinary terminal it was simply never there. A line of its own is what the
+// panel already does and what was asked for.
+//
+// Every figure says "left", because Codex counts down where Claude counts up.
+function codexLine(built, options) {
+  const opts = options || {};
+  const columns = Number.isFinite(opts.columns) && opts.columns > 0 ? opts.columns : 80;
+  const mode = opts.mode || 'none';
+  const tick = Number.isFinite(opts.tick) ? opts.tick : 0;
+  const reduced = Boolean(opts.reduced);
+  const ascii = Boolean(opts.ascii);
+
+  const block = built && built.codex;
+  if (!block || !Array.isArray(block.rows) || !block.rows.length) return '';
+  // Nothing readable at all is silence, not a line of dashes.
+  if (!block.rows.some((row) => row.percentLeft !== null)) return '';
+
+  // The name, not a mark: there is no ChatGPT logo a terminal font can draw.
+  const glyph = bars.paint(bars.CODEX_LABEL, bars.THEME.codex, mode);
+  const plan = block.plan ? bars.dim(String(block.plan), mode) : '';
+
+  const segment = (row, width, shorter) => {
+    const label = (shorter ? SHORTER_CODEX : SHORT_CODEX)[row.key] || row.key;
+    // A window whose reading has rolled over says so rather than vanishing: on
+    // a line of its own there is room, and dropping it silently would read as
+    // "Codex has one window" when it has two.
+    if (row.percentLeft === null) return label + ' ' + bars.dim(row.percentText, mode);
+    const text = Math.floor(row.percentLeft) + '% left';
+    const painted = row.level === 'fill' ? text : bars.paint(text, bars.levelColour(row.level), mode);
+    if (!width) return label + ' ' + painted;
+    return (
+      label + ' ' + bars.bar(row.percentLeft, width, { mode, level: row.level, ascii, tick, reduced }) + ' ' + painted
+    );
+  };
+
+  const attempts = [
+    { width: 10, head: true },
+    { width: 8, head: true },
+    { width: 6, head: true },
+    { width: 6, head: false },
+    { width: 4, head: false },
+    { width: 0, head: false },
+    { width: 0, head: false, shorter: true },
+    { width: 0, head: false, shorter: true, gap: ' ' },
+    // Last of all, only the windows that have a number. "5h rolling" is ten
+    // columns saying nothing a figure would not, and in a pane this narrow it
+    // is the difference between the line fitting and being clipped.
+    { width: 0, head: false, shorter: true, gap: ' ', readable: true },
+  ];
+
+  let text = '';
+  for (const attempt of attempts) {
+    const gap = attempt.gap || '  ';
+    const rows = attempt.readable ? block.rows.filter((row) => row.percentLeft !== null) : block.rows;
+    if (!rows.length) continue;
+    const body = rows.map((row) => segment(row, attempt.width, attempt.shorter)).join(gap);
+    // "Codex · ChatGPT Plus", the way the Claude line separates its model from
+    // its effort. Without the dot the two ran together as "Codex ChatGPT Plus".
+    const label = attempt.head && plan ? glyph + ' ' + bars.dim('·', mode) + ' ' + plan + gap : glyph + ' ';
+    text = label + body;
+    if (bars.visibleWidth(text) <= columns) return text;
+  }
+  return text;
+}
+
 function readStdin() {
   return new Promise((resolve) => {
     if (process.stdin.isTTY) return resolve('');
@@ -317,6 +402,12 @@ async function main(argv) {
       input = null;
     }
     if (input && typeof input !== 'object') input = null;
+    // Claude Code handing this its own status-line JSON settles which agent is
+    // running, and it beats any guess made from the environment. Anyone with
+    // CODEX_HOME set for their Codex install was otherwise detected as Codex
+    // here and got a blank status line under Claude Code, with nothing to say
+    // why - detection is only meant to be the fallback for a hand-run script.
+    if (input && (input.session_id || input.model)) usage.setHost(host.CLAUDE);
 
     const state = statusline.readState();
     if (state && state.chain && state.previous && state.previous.type === 'command' && state.previous.command) {
@@ -361,13 +452,48 @@ async function main(argv) {
       headersAt: slot ? slot.headersAt : null,
       model: slot ? slot.model : null,
       modelName: slot ? slot.modelName : null,
-      effort: slot ? slot.effort : null,
+      // Claude Code hands this line the effort outright, so the slot is
+      // already current and nothing else need be read. It is only when the
+      // slot has none - the very first update of a session, or a build that
+      // does not send it - that the transcript is worth a look.
+      effort:
+        slot && slot.effort
+          ? slot.effort
+          : view.pickEffort(
+              null,
+              usage.liveEffort(mine || (slot && slot.sessionId) || null),
+              collected.settings ? collected.settings.effortLevel : null
+            ),
       working: own.working || (gapMeansWorking(settings) && isWorking(slot, now)),
       ultrathink: Boolean(own.ultrathink),
+      ultracode: Boolean(own.ultracode) || settings.ultracode === true,
       settingsModel: collected.settings ? collected.settings.model : null,
       env,
     });
-    const text = line(built, {
+    // The other agent's meter, from its rollouts on disk. Required lazily and
+    // guarded by a single stat, so a machine without Codex pays nothing, and
+    // wrapped because a status line must never fail over an optional row.
+    // USAGE_LIMITS_CODEX_ROW=off turns it off.
+    built.codex = null;
+    if (String(env.USAGE_LIMITS_CODEX_ROW || '').toLowerCase() !== 'off' && host.codexHasSessions()) {
+      try {
+        const codex = require('./codex.js');
+        const other = codex.collect(now);
+        const block = view.buildCodex({
+          now,
+          utilization: other.utilization,
+          fetchedAtMs: other.snapshotFetchedAt,
+          windowSpecs: other.windowSpecs,
+          plan: other.plan,
+          windowless: other.windowless,
+        });
+        if (block.present) built.codex = block;
+      } catch (err) {
+        // No Codex row, and the Claude line is unaffected.
+      }
+    }
+
+    const drawn = {
       columns: Math.max(20, (Number(env.COLUMNS) || 80) - STATUSLINE_MARGIN),
       // Claude Code captures the output, so stdout is never a TTY here, and
       // ANSI is supported all the same.
@@ -376,8 +502,12 @@ async function main(argv) {
       reduced: motionOff(settings, env),
       ascii: String(env.USAGE_LIMITS_ASCII || '') === '1',
       clock: clockFor(settings, env),
-    });
-    await out((chained ? chained + '\n' : '') + text + '\n');
+    };
+    const text = line(built, drawn);
+    // Underneath, on its own line. Claude Code draws every line the status
+    // line prints, which is how a chained status line already works.
+    const other = codexLine(built, drawn);
+    await out((chained ? chained + '\n' : '') + text + (other ? '\n' + other : '') + '\n');
     return 0;
   } catch (err) {
     if (chained) await out(chained + '\n');
@@ -401,6 +531,7 @@ module.exports = {
   gapMeansWorking,
   ownState,
   line,
+  codexLine,
   runPrevious,
   clockFor,
   motionOff,

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

@@ -10,18 +10,27 @@
 //   - Codex has the whole hook engine. The binary carries UserPromptSubmit,
 //     SessionStart, PreToolUse and the rest, and `codex features list` reports
 //     `hooks` as stable and enabled.
-//   - A plugin cannot ship one. `plugin_hooks` is reported as `removed`.
-//   - And on codex-cli 0.151.0-alpha.7.2 nothing fires it. Measured, with a
-//     hook whose only job was to write a file: not from ~/.codex/hooks.json,
-//     not from a `[hooks]` table in config.toml, not from ~/.codex/hooks/, and
-//     not in `codex exec` or the desktop app. The engine is present and inert.
+//   - A plugin cannot ship one. `plugin_hooks` is reported as `removed`, so a
+//     `hooks` field in .codex-plugin/plugin.json is accepted and ignored.
+//   - On codex-cli 0.151.0-alpha.7.2 nothing fired hooks from anywhere. On
+//     0.153.4 the user-level ~/.codex/hooks.json does run them, but only after
+//     a one-time review: the terminal UI opens with "Hooks need review - hooks
+//     can run outside the sandbox after you trust them", and the choices are
+//     "Trust all and continue" or "Continue without trusting (hooks won't
+//     run)". The trust is persisted as a hash of the hooks, so a hook this
+//     script rewrites has to be trusted again. The desktop app never shows
+//     that review, which is why a machine using only the app can have the
+//     hooks installed for weeks and never once run them.
 //
-// So the hooks are still written, because they cost nothing and will start
-// working the day that build ships. But they are not what makes this automatic
-// today. AGENTS.md is: Codex reads it at the top of every session in scope,
-// which is the one always-on instruction channel that actually runs. It cannot
-// carry live numbers the way a hook can, so instead it tells Codex to go and
-// read them at the start of a piece of work.
+// So the hooks are written, and `status` says whether anything has ever run
+// them. But the trust review is the user's to accept, deliberately - this
+// script does not forge a trust hash to get round a safety prompt - and until
+// it is accepted the hooks are inert. AGENTS.md is what works regardless:
+// Codex reads it at the top of every session in scope, which is the one
+// always-on instruction channel. It cannot carry live numbers the way a hook
+// can, so instead it tells Codex to go and read them at the start of a piece
+// of work - and, since the effort setting is what actually empties a Codex
+// window, to look at that.
 //
 // Both halves are marked and reversible, and neither touches anything else in
 // the files it edits.
@@ -40,6 +49,10 @@ const host = require('./host.js');
 const EVENTS = [
   { event: 'UserPromptSubmit', script: 'brief.js', status: 'Checking usage limits' },
   { event: 'PostToolUse', script: 'pulse.js', status: 'Checking usage limits' },
+  // Codex has subagents too, and a turn that hands its work to them makes no
+  // tool calls of its own for as long as they run. Same quiet refresh as on
+  // Claude Code; pulse.js sees the event name and says nothing.
+  { event: 'SubagentStop', script: 'pulse.js', status: 'Checking usage limits' },
 ];
 const EVENT = EVENTS[0].event;
 // Ten seconds is the same budget the Claude hook gets. The brief caches the
@@ -50,6 +63,23 @@ function hooksFile() {
   return path.join(host.codexHome(), 'hooks.json');
 }
 
+// Whether Codex has ever actually run one of these hooks. Each writes a small
+// state file beside the rollouts the first time it fires, so the hooks being
+// installed with none of those present means the trust review has never been
+// accepted - which is the state a machine using only the desktop app sits in
+// indefinitely, with no error anywhere to say so.
+function everRan() {
+  const dir = host.codexHome();
+  return ['usage-limits-pulse.json', 'usage-limits-brief.json'].some((name) =>
+    host.exists(path.join(dir, name))
+  );
+}
+
+const TRUST_STEP =
+  'Codex runs hooks from this file only after a one-time review. Start `codex` in a\n' +
+  '  terminal once and choose "Trust all and continue"; the desktop app never shows\n' +
+  '  that review. Rewriting the hooks changes their hash, so `on` means reviewing again.';
+
 function briefScript(name) {
   return path.join(__dirname, name || 'brief.js');
 }
@@ -120,8 +150,7 @@ function agentsBlock() {
     AGENTS_START,
     '## Usage limits',
     '',
-    'Before starting any substantial piece of work, and again if it grows or starts',
-    'looping, run:',
+    'Before starting any substantial piece of work, run:',
     '',
     '    node ' + quote(briefScript('usage.js')) + ' --host codex',
     '',
@@ -130,10 +159,28 @@ function agentsBlock() {
     'it does not fit, say what you will do now and what you will leave for after the',
     'reset, rather than starting and being cut off partway.',
     '',
+    'The number is an estimate that shrinks as the work runs, so run it again after',
+    'every ten or so tool-heavy turns, after any step that took minutes, and before',
+    'the last long step of a job. When the turns left are fewer than the steps still',
+    'ahead, or under fifteen, stop at the next clean boundary: save the work, write',
+    'what is done and what is next to WORK-PLAN.md in the working directory, commit',
+    'if there is a repository, and say so. Never push on into the limit: a job cut',
+    'off partway loses the handoff as well as the work.',
+    '',
+    'Below ten percent left, or a few turns, the check itself was the last cheap',
+    'thing: start nothing new, write the handoff in this same turn, and end the',
+    'turn. On 8 September a session read the meter at five percent, carried on,',
+    'and lost the rest of the window inside that turn.',
+    '',
     'This is about the order of the work, not the amount. Do not economise, shorten',
     'answers or skip verification to save budget: unspent budget is lost at the',
-    'reset, not carried over. Do not run this on every reply; once at the start of a',
-    'piece of work is enough.',
+    'reset, not carried over.',
+    '',
+    'The reasoning effort in config.toml is what actually empties a window: one',
+    'ordinary task at ultra effort on a Plus plan can take a whole five-hour window.',
+    'The report measures what each effort costs here and prices the window at the',
+    'one set now; if it says the window holds only a few turns at this effort, say',
+    'so, and use a lower effort for work that does not need the thinking.',
     AGENTS_END,
   ].join('\n');
 }
@@ -283,10 +330,14 @@ function status() {
           (agentsStale() ? '\n  It points at another copy of the plugin, so run `on`.' : '')
         : 'AGENTS.md block missing from ' + agentsFile() + '. Run `on`.'
   );
-  lines.push(
-    'Hooks are written for when Codex runs them; on current builds they do not fire, ' +
-      'so the AGENTS.md block is what makes this work.'
-  );
+  if (!missing.length) {
+    lines.push(
+      everRan()
+        ? 'Codex has run these hooks: their state files are beside its rollouts.'
+        : 'Codex has never run these hooks. ' + TRUST_STEP + '\n' +
+          '  Until then the AGENTS.md block is what makes this work.'
+    );
+  }
 
   return {
     installed: !missing.length && agents,
@@ -344,7 +395,7 @@ function enable() {
       '    of work. This is the part that works today.\n' +
       '  ' + hooksFile() + '\n' +
       EVENTS.map((one) => '    ' + one.event + '  ' + command(one.script)).join('\n') + '\n' +
-      '    Ready for when Codex runs plugin-less hooks; inert on current builds.\n' +
+      '    ' + TRUST_STEP.replace(/\n  /g, '\n    ') + '\n' +
       'Start a new thread for it to take effect. Run `off` to remove both.',
   };
 }

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

@@ -61,12 +61,17 @@ function parseArgs(argv) {
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === '--dry-run') args.dryRun = true;
+    else if (arg === '--host') args.host = argv[++i];
+    else if (arg.startsWith('--host=')) args.host = arg.slice(7);
     else if (arg === '--effort') args.effort = argv[++i];
     else if (arg === '--model') args.model = argv[++i];
     else if (arg.startsWith('--effort=')) args.effort = arg.slice('--effort='.length);
     else if (arg.startsWith('--model=')) args.model = arg.slice('--model='.length);
-    else if (!args.command) args.command = arg;
+    else if (!args.command && !arg.startsWith('-')) args.command = arg;
+    else throw new Error('Unknown argument: ' + arg);
+    if (['--host', '--effort', '--model'].includes(arg) && (!argv[i] || argv[i].startsWith('--'))) throw new Error('Missing value for ' + arg);
   }
+  for (const key of ['host', 'effort', 'model']) if (Object.hasOwn(args, key) && args[key] === '') throw new Error('Missing value for --' + key);
   if (!args.command) args.command = 'status';
   return args;
 }
@@ -166,6 +171,9 @@ function describe(settings, state) {
 
 function main(argv) {
   const args = parseArgs(argv);
+  const host = require('./host.js');
+  if (args.host && !['codex', 'claude'].includes(args.host)) throw new Error('Expected --host codex or --host claude');
+  if ((args.host || host.detect(argv)) === host.CODEX) return require('./codex-lowpower.js').main(args);
   const file = settingsFile();
   const settings = readJson(file) || {};
   const state = readJson(stateFile());
@@ -214,7 +222,7 @@ function main(argv) {
     return 0;
   }
 
-  process.stderr.write('usage: lowpower.js [status|on|off] [--effort level] [--model name] [--dry-run]\n');
+  process.stderr.write('usage: lowpower.js [status|on|off] [--host claude|codex] [--effort level] [--model name] [--dry-run]\n');
   return 1;
 }
 

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

@@ -46,6 +46,9 @@ const POLL_FLOOR_MS = 15 * SECOND;
 const FILE_CHECK_MS = SECOND;
 const FRAME_MS = 100;
 const MIN_COLUMNS = 24;
+// The widest thing that follows a Codex bar, plus its space: "no reading" is
+// ten characters and "100% left" is nine.
+const CODEX_SUFFIX = 11;
 const TITLE = 'Claude usage';
 const LEVEL_RANK = { fill: 0, warning: 1, error: 2 };
 
@@ -156,8 +159,38 @@ async function snapshot(options) {
   const slots = onCodex ? {} : feed.readFeed();
   // 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 marks = onCodex ? {} : activity.read();
+  // The session to describe: the one this display was already describing,
+  // else the newest mark. Every session writes a mark, but only a terminal
+  // session writes a feed slot, so choosing from the feed meant a VS Code
+  // window with no status line was never the one described and its own
+  // ultrathink never showed.
+  const freshest = Object.keys(marks)
+    .filter((key) => key !== '_' && marks[key] && Number.isFinite(marks[key].at) && now - marks[key].at <= activity.STALE_MS)
+    .sort((a, b) => marks[b].at - marks[a].at)[0];
+  const sticky = opts.sessionId && marks[opts.sessionId] && now - marks[opts.sessionId].at <= feed.STICKY_QUIET_MS;
+  const described = (sticky ? opts.sessionId : null) || freshest || opts.sessionId || null;
+  // A described session with no status line of its own (VS Code) must not be
+  // dressed in another session's slot: that is how a Fable window came to say
+  // Opus. Its transcript speaks for it instead. Only a panel with no session
+  // at all falls back to the newest slot on the machine.
+  const slot = (described && slots[described]) || (described ? null : feed.stickySlot(slots, opts.sessionId, now));
+  const spoken = !onCodex && described && !slot ? usage.liveModel(described) : null;
+  // The marks are machine-wide, and this panel describes ONE session. Reading
+  // the machine-wide summary here is what let a prompt in another window put
+  // ultrathink on this window's bars. When the session being described is
+  // known, its own mark is the only one that speaks for it.
+  // A panel that was given a session speaks for that session alone. A panel
+  // with none of its own is the machine's, and there the newest working
+  // session's word is the one shown - two windows in different modes would
+  // otherwise make it depend on whose tool call landed last.
+  const seen = onCodex
+    ? { working: codexWorking(now), ultracode: false, ultrathink: false, model: null }
+    : opts.sessionId && marks[opts.sessionId]
+      ? Object.assign(feed.ownState(marks, opts.sessionId, now), {
+          model: (marks[opts.sessionId] && marks[opts.sessionId].model) || null,
+        })
+      : activity.summarise(marks, now);
   const settings = onCodex ? {} : settingsFor();
 
   const built = view.build({
@@ -168,26 +201,28 @@ async function snapshot(options) {
     windowSpecs: collected.windowSpecs || null,
     headers: slot ? slot.rateLimits : null,
     headersAt: slot ? slot.headersAt : null,
-    model: (slot && slot.model) || seen.model || null,
+    model: (slot && slot.model) || seen.model || (spoken && spoken.model) || null,
     modelName: slot ? slot.modelName : 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),
+    // Whichever of the status line and the transcript spoke last. The setting
+    // is only the last resort: a panel beside a VS Code window has no status
+    // line to ask, and the setting there never moves, which is how it came to
+    // report xhigh through a session running at max.
+    effort: view.pickEffort(
+      slot && slot.effort ? { effort: slot.effort, at: slot.at } : null,
+      onCodex || !described ? null : usage.liveEffort(described),
+      collected.settings ? collected.settings.effortLevel : null
+    ),
     working: seen.working || feed.isWorking(slot, now),
     // 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),
+    ultracode: Boolean(seen.ultracode) || settings.ultracode === true,
     settingsModel: collected.settings ? collected.settings.model : null,
     outcome,
     env,
   });
   built.now = now;
-  built.sessionId = slot && slot.sessionId ? slot.sessionId : null;
+  built.sessionId = described || (slot && slot.sessionId) || null;
   built.host = onCodex ? 'codex' : 'claude';
   built.title = onCodex ? 'Codex usage' : TITLE;
   built.plan = collected.plan || null;
@@ -203,6 +238,28 @@ async function snapshot(options) {
   // the report, so it is taken with the readings, not with every frame; the
   // frames in between carry the last answer forward.
   built.pace = opts.pace !== undefined ? opts.pace : await paceOf(now);
+  // The other agent's meter, drawn under this one's.
+  //
+  // Read from Codex's own rollouts on disk and nothing else: no child process,
+  // no network, no waiting. Codex having nothing to say, or not being installed
+  // at all, must never be a reason the Claude panel is late or absent.
+  built.codex = null;
+  if (!onCodex && host.codexHasSessions()) {
+    try {
+      const other = codex.collect(now);
+      const block = view.buildCodex({
+        now,
+        utilization: other.utilization,
+        fetchedAtMs: other.snapshotFetchedAt,
+        windowSpecs: other.windowSpecs,
+        plan: other.plan,
+        windowless: other.windowless,
+      });
+      if (block.present) built.codex = block;
+    } catch (err) {
+      // An unreadable Codex is simply no Codex row.
+    }
+  }
   // Whether the panel is allowed the network at all, which is what the footer
   // reports. A frame rebuilt from disk between readings is not "network off".
   built.fetch = opts.network !== undefined ? Boolean(opts.network) : Boolean(opts.fetch);
@@ -244,10 +301,65 @@ function codexWorking(now) {
   }
 }
 
-// The sessions this machine has heard from lately, from every file the hooks
-// and the status line keep. The tally is required lazily: it requires usage.js
-// back, and this module is loaded by the VS Code extension too.
+// Codex runs no hooks on this machine, so it writes no marks, and its sessions
+// never appeared beside the Claudes. Its rollout files say what a mark would:
+// a rollout appended in the last half minute is a session at work, one touched
+// within the stale window is one idling. The first line of a rollout is the
+// session's meta record - its id, its working directory, what launched it.
+function codexSessions(now, opts) {
+  const o = opts || {};
+  const stale = Number.isFinite(o.staleMs) ? o.staleMs : activity.STALE_MS;
+  const busyMs = Number.isFinite(o.busyMs) ? o.busyMs : 30 * SECOND;
+  let files = [];
+  try {
+    files = Array.isArray(o.files) ? o.files : codex.rolloutFiles(now - stale);
+  } catch (err) {
+    return [];
+  }
+  const rows = [];
+  for (const entry of files) {
+    if (!entry || !Number.isFinite(entry.at) || entry.at < now - stale) continue;
+    let meta = null;
+    try {
+      const fd = fs.openSync(entry.file, 'r');
+      const buf = Buffer.alloc(4096);
+      const n = fs.readSync(fd, buf, 0, 4096, 0);
+      fs.closeSync(fd);
+      const first = buf.toString('utf8', 0, n).split(String.fromCharCode(10))[0];
+      const parsed = JSON.parse(first);
+      meta = parsed && parsed.payload && typeof parsed.payload === 'object' ? parsed.payload : null;
+    } catch (err) {
+      meta = null;
+    }
+    const id = (meta && (meta.session_id || meta.id)) || path.basename(entry.file, '.jsonl');
+    rows.push({
+      key: 'codex:' + id,
+      id,
+      host: 'codex',
+      state: entry.at >= now - busyMs ? 'working' : 'idle',
+      stateAt: entry.at,
+      lastAt: entry.at,
+      model: null,
+      modelName: 'Codex' + (meta && meta.originator ? ' (' + String(meta.originator) + ')' : ''),
+      cwd: meta && meta.cwd ? String(meta.cwd) : null,
+      ultracode: false,
+      ultrathink: false,
+    });
+  }
+  rows.sort((x, y) => y.lastAt - x.lastAt);
+  return rows;
+}
+
+// Every session this machine has heard from lately: the Claudes from the
+// files the hooks and the status line keep, and the Codexes from their own
+// rollouts.
 function loadSessions(now) {
+  return claudeSessions(now).concat(codexSessions(now));
+}
+
+// The tally is required lazily: it requires usage.js back, and this module is
+// loaded by the VS Code extension too.
+function claudeSessions(now) {
   let tallyList = [];
   try {
     const tally = require('./tally.js');
@@ -303,6 +415,22 @@ function shortTitle(row) {
   return String(row.title).replace(/^Current week /, 'Week ').replace(/^Current /, '');
 }
 
+// Codex's own row titles are already short; these are for a very narrow pane.
+function shortCodexTitle(row) {
+  if (row.key === 'five_hour') return '5h';
+  if (row.key === 'seven_day') return 'Week';
+  return String(row.title).replace(/ limit$/, '');
+}
+
+// The Codex rows say "left", so their sublines have to as well, and they must
+// never point at a Claude Code command to fix a Codex reading.
+function codexSubline(row, mode, opts) {
+  if (row.stale) return bars.dim('window rolled over since Codex last ran', mode);
+  if (row.percentLeft === null) return bars.dim('no reading yet', mode);
+  const reset = bars.formatReset(row.msToReset, row.resetsAtMs, opts.now, { clock: opts.clock });
+  return reset ? bars.dim(reset, mode) : '';
+}
+
 function subline(row, mode, opts) {
   if (row.stale) return bars.dim('window rolled over, taking a fresh reading', mode);
   if (row.unreported) return bars.dim('not reported yet, run /usage in Claude Code', mode);
@@ -408,6 +536,42 @@ function render(built, options) {
     });
   }
 
+  // The Codex block, in the same shapes and the same colours, counting the
+  // other way: Codex reports what is LEFT, so its bars drain as they are spent
+  // where Claude's fill. The mark is a plain hexagon rather than the Codex
+  // logo, which is OpenAI's Blossom and not ours to recolour.
+  if (built.codex && built.codex.rows.length) {
+    const block = built.codex;
+    const lines = [
+      bars.bold(bars.paint(block.title, bars.THEME.codex, mode), mode),
+    ];
+    // "85% left" is five characters wider than "85%", so the Codex bars get
+    // their own width. Sharing the Claude one clipped every Codex row.
+    const codexWidth = Math.max(6, Math.min(50, columns - CODEX_SUFFIX));
+    for (const row of block.rows) {
+      const percent =
+        row.level === 'fill' ? row.percentText : bars.paint(row.percentText, bars.levelColour(row.level), mode);
+      lines.push(bars.bold(columns < 34 ? shortCodexTitle(row) : row.title, mode));
+      lines.push(
+        (row.percentLeft === null
+          ? bars.paint((ascii ? '-' : '░').repeat(codexWidth), bars.THEME.empty, mode)
+          : // No ultracode or ultrathink styling here: those describe how this
+            // Claude is running and have nothing to do with the other agent.
+            bars.bar(row.percentLeft, codexWidth, { mode, level: row.level, ascii, tick, reduced })) +
+          ' ' +
+          percent
+      );
+      const sub = codexSubline(row, mode, { now, clock });
+      if (sub) lines.push(sub);
+    }
+    const tail = [];
+    if (block.plan) tail.push(block.plan);
+    if (block.note) tail.push(block.note);
+    else if (Number.isFinite(block.ageMs)) tail.push('reading from ' + since(block.ageMs) + ' ago');
+    if (tail.length) lines.push(bars.dim(tail.join(' · '), mode));
+    body.push({ lines });
+  }
+
   // The other Claudes. One row each: what it runs, where, and whether it is
   // working right now, with its own spinner when it is.
   const list = Array.isArray(built.sessionsList) ? built.sessionsList : [];
@@ -796,6 +960,7 @@ async function main(argv) {
 }
 
 module.exports = {
+  codexSessions,
   HELP,
   TITLE,
   MIN_COLUMNS,