claude-usage-limits 1.11.6 → 1.13.0

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

@@ -443,7 +443,10 @@ function readingsOf(meter) {
   for (const entry of SLOTS) {
     const window = meter[entry.slot];
     if (!window || typeof window !== 'object') continue;
-    const percent = Number(window.used_percent);
+    // Number(null) is 0, and a null percentage read as "0% used" is worse
+    // than no reading at all. Only an actual number counts.
+    const raw = window.used_percent;
+    const percent = raw === null || raw === undefined || raw === '' ? NaN : Number(raw);
     if (!Number.isFinite(percent)) continue;
 
     const minutes = Number(window.window_minutes);
@@ -482,9 +485,21 @@ function utilizationFrom(meter) {
   // account has no rolling limit and usage scales with credits. Returning null
   // here would throw away the plan and the credit balance, which on such an
   // account are the only figures there are.
+  //
+  // A slot that IS there but carries no readable percentage is a different
+  // thing again: the meter answered without numbers, which happens around a
+  // limit hit. Calling that flexible pricing told Codex on 2026-09-07 that its
+  // Plus account had no window to run down, minutes after the window ran out.
+  const slotsPresent = SLOTS.filter((entry) => meter[entry.slot] && typeof meter[entry.slot] === 'object').length;
+  // Consumer plans are metered by windows without exception; only the
+  // business-side plans can be on flexible pricing. So on Plus, Pro, Go or
+  // Free a meter with no windows in it is a meter that failed to read them.
+  const planType = typeof meter.plan_type === 'string' ? meter.plan_type : '';
+  const consumer = /^(free|go|plus|pro|prolite)$/i.test(planType);
   const credits = meter.credits && typeof meter.credits === 'object' ? meter.credits : null;
   return {
-    windowless: specs.length === 0,
+    windowless: specs.length === 0 && slotsPresent === 0 && !consumer,
+    unreadable: specs.length === 0 && (slotsPresent > 0 || consumer),
     utilization: specs.length ? utilization : null,
     specs,
     planType: typeof meter.plan_type === 'string' ? meter.plan_type : null,
@@ -599,31 +614,81 @@ function latestMeter(events) {
   return null;
 }
 
+// The meter is written next to every request, so the newest one is always near
+// the END of a rollout. Only the tail is read.
+//
+// This used to read whole files, and a rollout on this machine reaches 32 MB;
+// twelve of those is a third of a gigabyte pulled through a string on a path
+// that the status line takes every few hundred milliseconds. A megabyte of
+// tail holds hundreds of token_count lines, which is far more than enough.
+const TAIL_BYTES = 1024 * 1024;
+
+function readTail(file, bytes) {
+  let size = 0;
+  try {
+    size = fs.statSync(file).size;
+  } catch (err) {
+    return null;
+  }
+  const from = Math.max(0, size - bytes);
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+  } catch (err) {
+    return null;
+  }
+  try {
+    const length = size - from;
+    if (length <= 0) return { text: '', partial: false };
+    const buffer = Buffer.allocUnsafe(length);
+    let read = 0;
+    while (read < length) {
+      const got = fs.readSync(fd, buffer, read, length - read, from + read);
+      if (got <= 0) break;
+      read += got;
+    }
+    return { text: buffer.toString('utf8', 0, read), partial: from > 0 };
+  } catch (err) {
+    return null;
+  } finally {
+    try {
+      fs.closeSync(fd);
+    } catch (err) {
+      // Already closed.
+    }
+  }
+}
+
+function meterFromLines(text, partial) {
+  const lines = text.split('\n');
+  // The first line of a tail is a fragment of whatever it landed in the middle
+  // of, so it is never parsed.
+  const floor = partial ? 1 : 0;
+  for (let index = lines.length - 1; index >= floor; index -= 1) {
+    const line = lines[index];
+    if (!line || line.indexOf('"token_count"') === -1) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (err) {
+      continue;
+    }
+    const meter = parsed && parsed.payload && parsed.payload.rate_limits;
+    const at = Date.parse(parsed && parsed.timestamp);
+    if (meter && Number.isFinite(at)) return { meter, at };
+  }
+  return null;
+}
+
 // Scanning only the newest few rollouts, for the meter alone. `collect` runs on
 // the status-line path where a full scan would be far too slow.
 function meterFromDisk() {
   const files = rolloutFiles(NaN).slice(-12).reverse();
   for (const entry of files) {
-    let raw;
-    try {
-      raw = fs.readFileSync(entry.file, 'utf8');
-    } catch (err) {
-      continue;
-    }
-    const lines = raw.split('\n');
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-      const line = lines[index];
-      if (!line || line.indexOf('"token_count"') === -1) continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch (err) {
-        continue;
-      }
-      const meter = parsed && parsed.payload && parsed.payload.rate_limits;
-      const at = Date.parse(parsed && parsed.timestamp);
-      if (meter && Number.isFinite(at)) return { meter, at };
-    }
+    const tail = readTail(entry.file, TAIL_BYTES);
+    if (!tail) continue;
+    const found = meterFromLines(tail.text, tail.partial);
+    if (found) return found;
   }
   return null;
 }
@@ -752,6 +817,8 @@ function collect(now, options) {
     // what flexible pricing looks like. That is a different thing from having
     // found nothing to read, and it needs to be said differently.
     windowless: Boolean(mapped && mapped.windowless),
+    // The meter reported window slots but no readable percentage in them.
+    unreadable: Boolean(mapped && mapped.unreadable),
     windowSpecs: mapped ? mapped.specs : null,
     reachedType: mapped ? mapped.reachedType : null,
     spendControlReached: Boolean(mapped && mapped.spendControlReached),
@@ -948,6 +1015,9 @@ module.exports = {
   planFrom,
   latestMeter,
   meterFromDisk,
+  readTail,
+  meterFromLines,
+  TAIL_BYTES,
   liveFile,
   attemptFile,
   readLiveMeter,

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;
 }