claude-usage-limits 1.11.7 → 1.13.1

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

@@ -18,6 +18,9 @@ const host = require('./host.js');
 const tally = require('./tally.js');
 const activity = require('./activity.js');
 const live = require('./live.js');
+const relay = require('./relay.js');
+const reading = require('./reading.js');
+const voice = require('./voice.js');
 
 const SECOND = 1000;
 const DAY = 24 * 60 * 60 * 1000;
@@ -59,6 +62,17 @@ const DEFAULTS = {
 // A hook has ten seconds; the reading gets four of them at most.
 const REFRESH_TIMEOUT_MS = 4000;
 
+// The hook is given ten seconds, and a live reading may take four of them, so
+// the transcript scan gets five and the last second is slack. A warm scan
+// takes about a quarter of a second; this is the guard for the first run on a
+// machine with months of transcripts, where the alternative is the hook being
+// killed and Claude being told nothing at all.
+const SCAN_BUDGET_MS = 5000;
+
+// How far into the hook arming may still start. See relayState: the task
+// registration is about a second and the hook is allowed ten.
+const ARM_DEADLINE_MS = 5000;
+
 // Past this much of a per-model week, say how to free it. Below it the advice
 // is noise: there is room, and the model in use is the right one.
 const HALF_SPENT = 50;
@@ -177,12 +191,10 @@ function mergeCache(all, sessionId, entry, keep) {
 }
 
 function writeCache(all) {
-  try {
-    fs.mkdirSync(path.dirname(cacheFile()), { recursive: true });
-    fs.writeFileSync(cacheFile(), JSON.stringify(all), 'utf8');
-  } catch (err) {
-    // A cache miss costs a scan. A crash costs the prompt. Prefer the scan.
-  }
+  // Never throws: a cache miss costs a scan, a crash costs the prompt. Atomic
+  // because every open window's prompt hook writes this same file, and a torn
+  // read by one of them wiped the others' slots on the way back.
+  usage.writeJsonAtomic(cacheFile(), all);
 }
 
 function settings() {
@@ -356,6 +368,41 @@ function count(value, word) {
   return value + ' ' + word + (Math.abs(value) === 1 ? '' : 's');
 }
 
+// The other agent's meter, in one clause.
+//
+// Codex reports what is LEFT where Claude reports what is USED, so every
+// figure here carries the word "left" - a bare percentage next to Claude's
+// would be read as the same kind of number and mean the opposite thing.
+//
+// Read from Codex's rollouts on disk. Nothing spawns Codex, nothing waits on
+// it, and a machine without it pays one stat call.
+function codexSummary(now) {
+  try {
+    if (usage.isCodex() || !host.codexHasSessions()) return null;
+    const display = require('./view.js');
+    const codex = require('./codex.js');
+    const other = codex.collect(now);
+    const block = display.buildCodex({
+      now,
+      utilization: other.utilization,
+      fetchedAtMs: other.snapshotFetchedAt,
+      windowSpecs: other.windowSpecs,
+      plan: other.plan,
+      windowless: other.windowless,
+    });
+    if (!block.present) return null;
+    const names = { five_hour: '5-hour', seven_day: 'weekly' };
+    const bits = block.rows
+      .filter((row) => row.percentLeft !== null)
+      .map((row) => (names[row.key] || row.title) + ' ' + Math.floor(row.percentLeft) + '% left');
+    if (!bits.length) return null;
+    return { plan: block.plan, bits, stale: block.state !== 'live' };
+  } catch (err) {
+    // An unreadable Codex is simply no Codex clause.
+    return null;
+  }
+}
+
 function describeWindow(window) {
   if (!window) return null;
   if (window.stale) return window.label + ' rolling over';
@@ -460,6 +507,51 @@ function briefText(parts) {
         'the amount that ran out last time, not a fresh allowance.'
     );
   }
+  // The other agent, when there is one on this machine. Its own budget, its
+  // own direction: Codex counts down.
+  if (parts.codex && parts.codex.bits.length) {
+    sentences.push(
+      'Codex' + (parts.codex.plan ? ' (' + parts.codex.plan + ')' : '') + ' has ' +
+        parts.codex.bits.join(' and ') +
+        (parts.codex.stale ? ', from the last reading it wrote' : '') + '.'
+    );
+  }
+  // The effort setting changes the PRICE of a turn rather than how many there
+  // are, and the blended headroom above hides that completely: an account that
+  // has just moved to a dearer effort goes on being priced at the old one until
+  // enough dear turns have landed to drag the average up, and on a small window
+  // there is no "enough" - the window is gone first.
+  //
+  // A ChatGPT Plus account running gpt-6-astra at ultra effort emptied a whole
+  // five-hour window on one ordinary task while this hook reported room the
+  // entire way. Saying it here is what turns "plenty of room" into "about
+  // twenty turns" before the window is spent rather than after.
+  if (parts.effortWarning) {
+    const warning = parts.effortWarning;
+    const bits = [];
+    if (Number.isFinite(warning.turnsLeft)) {
+      const blended = warning.blendedTurnsLeft;
+      bits.push(
+        'at ' + warning.effort + ' effort this window holds about ' + count(warning.turnsLeft, 'turn') +
+          (Number.isFinite(blended) && blended > warning.turnsLeft
+            ? ', not the ' + blended + ' the headroom above suggests'
+            : '')
+      );
+    }
+    if (warning.cheaper && Number.isFinite(warning.cheaper.multiple)) {
+      bits.push(
+        warning.effort + ' writes about ' + warning.cheaper.multiple.toFixed(1) +
+          ' times the output per turn that ' + warning.cheaper.effort + ' does'
+      );
+    }
+    if (bits.length) {
+      sentences.push(
+        'The effort setting is what is spending this: ' + bits.join(', and ') +
+          '. Keep it where the work genuinely needs the thinking and drop it where it ' +
+          'does not; it changes what every turn costs, not how many you get.'
+      );
+    }
+  }
   // A per-model weekly is the one window effort cannot help with. Nothing you
   // do more cheaply on this model frees it; only running a different model
   // does, and that has to be said, because the obvious move at 90 percent is
@@ -526,6 +618,47 @@ function briefText(parts) {
     );
   }
 
+  if (parts.voiceNote) sentences.push('How this user wants to be written to: ' + parts.voiceNote);
+
+  // What the relay changes about all of this.
+  //
+  // With a wake booked, the end of the window stops being the end of the work,
+  // and the instruction at the wall changes shape: the handoff is no longer a
+  // note somebody has to find and read, it is the prompt this conversation
+  // will be handed back. That is worth two minutes of writing, and it is worth
+  // saying plainly, because a session told only "you are about to be cut off"
+  // spends its last turns hedging.
+  const carry = parts.relay;
+  if (carry && carry.armed) {
+    const wake = new Date(carry.armed.wakeAt);
+    sentences.push(
+      'A relay is armed: ' + (carry.justArmed ? 'booked just now' : 'booked') + ' for ' +
+        wake.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) + ', ' +
+        carry.config.graceMinutes + ' minutes after this window resets, and it will ' +
+        (carry.armed.mode === 'resume' ? 'hand your continuation straight back to this conversation' : 'notify the user with your continuation ready to open') +
+        '.' + (carry.armed.warning ? ' Caveat: ' + carry.armed.warning + '.' : '')
+    );
+    if (!carry.armed.continuation) {
+      sentences.push(
+        'Nothing has been written for it yet. Before this session ends, run ' +
+          'node "$CLAUDE_PLUGIN_ROOT/skills/usage-limits/scripts/relay.js" note "<what you would tell yourself>" ' +
+          'with what is done, what is next in order, which files are mid-change and what must be verified first. ' +
+          'That text is the prompt the relay delivers, so write it to be acted on, not read.'
+      );
+    }
+  }
+  if (carry && carry.last) {
+    sentences.push(
+      'The last relay ' +
+        (carry.last.outcome === 'resumed'
+          ? 'picked this work back up automatically after the previous reset (' + (carry.last.detail || 'resumed') + '); check what it did before repeating it'
+          : carry.last.outcome === 'notified'
+            ? 'left a notification after the previous reset rather than starting anything'
+            : 'ended as "' + carry.last.outcome + '"' + (carry.last.detail ? ' - ' + carry.last.detail : '')) +
+        '.'
+    );
+  }
+
   // Three states, and only the last one stops anything.
   //
   // The middle one is the one that keeps being got wrong. Near the wall the
@@ -538,7 +671,19 @@ function briefText(parts) {
     parts.pressure === 'gone'
       ? 'The budget is gone, so nothing further will run. Save what exists and ' +
         'write the handoff: what is finished, what is next and in what order, ' +
-        'which files are mid-change, and when the window resets.'
+        'which files are mid-change, and when the window resets.' +
+        (parts.relay && parts.relay.armed
+          ? ' Write it into the relay note as well as into your reply - that is ' +
+            'the copy that gets acted on when the window reopens.'
+          : '')
+      : parts.pressure === 'tight' && parts.relay && parts.relay.armed
+        ? 'The budget is nearly gone and the relay has it: being cut off now ' +
+          'costs the wait, not the work. So do not wind down, do not narrow the ' +
+          'request, and do not stop to ask whether to go on. Carry on at full ' +
+          'quality, save at clean boundaries, and put everything the next turn ' +
+          'needs into the relay note rather than into a summary for a person to ' +
+          'read. Say in one line what will land after the reset instead of ' +
+          'before it, then keep working until the window actually ends.'
       : parts.pressure === 'tight'
         ? 'The budget is nearly gone, so make being cut off cheap rather than ' +
           'doing less. Carry on with the whole request at full quality: this is ' +
@@ -631,6 +776,65 @@ function tallyContext(all, sessionId, now) {
   };
 }
 
+// The relay, decided once per prompt.
+//
+// Two things happen here and neither of them slows the work down. Above the
+// arming threshold, with a plan or an unfinished todo list to carry, a one-shot
+// wake is booked for a few minutes after the reset - a scheduled task costs
+// nothing and changes nothing about the turn in progress. And once a wake
+// exists, what the hook tells Claude at the wall changes: the handoff is no
+// longer a note for a person to find, it is the thing that will be handed back
+// automatically, so it is worth writing properly.
+//
+// It also reports what happened last time. A relay that fired while nobody was
+// watching is exactly the sort of thing a session should not have to be asked
+// about.
+function relayState(now, hookInput, binding, sessionId) {
+  try {
+    const state = relay.read();
+    const config = relay.settings(state);
+    const last = state.history[state.history.length - 1];
+    const recent = last && Number.isFinite(last.endedAt) && now - last.endedAt < 6 * 60 * 60 * 1000 ? last : null;
+    if (!config.enabled) return recent ? { enabled: false, last: recent } : null;
+
+    // Already armed for this session: nothing to decide, just say so.
+    if (state.armed && state.armed.id === sessionId) {
+      return { enabled: true, armed: state.armed, config, last: recent };
+    }
+    const work = relay.detectWork(hookInput && hookInput.transcript_path, {});
+    const able = relay.armable({ config, binding, sessionId, work });
+    if (!able.ok) return { enabled: true, why: able.why, config, last: recent, work };
+    // Registering a scheduled task measured 936 ms, and this hook has ten
+    // seconds of which the live reading may take four and the scan five. A
+    // hook that is killed tells Claude nothing at all, which is far worse than
+    // a relay that arms on the next prompt instead of this one - and if there
+    // is no next prompt, the session ended and there was nothing to carry.
+    if (Date.now() - now > ARM_DEADLINE_MS) {
+      return { enabled: true, why: 'no time left in this hook; arming on the next prompt', config, last: recent, work };
+    }
+    const armed = relay.arm({
+      now,
+      config,
+      // Registration must be finished, not merely started, inside the hook's
+      // ten seconds; the scheduler trims its own waits to this.
+      deadline: now + ARM_DEADLINE_MS + 4000,
+      sessionId,
+      binding,
+      work,
+      resetsAt: binding.resetsAt,
+      cwd: (hookInput && hookInput.cwd) || process.cwd(),
+      project: path.basename((hookInput && hookInput.cwd) || process.cwd()),
+      hostName: usage.currentHost(),
+    });
+    return armed.ok
+      ? { enabled: true, armed: armed.record, justArmed: true, config, last: recent, work }
+      : { enabled: true, error: armed.error, config, last: recent, work };
+  } catch (err) {
+    // Nothing about carrying work forward is worth breaking the prompt for.
+    return null;
+  }
+}
+
 async function run(now, hookInput) {
   if (String(process.env.USAGE_LIMITS_BRIEF || '').toLowerCase() === 'off') return '';
 
@@ -645,15 +849,22 @@ async function run(now, hookInput) {
   activity.mark(
     'working',
     sessionId,
-    {
-      // 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)
-      ),
-    },
+    Object.assign(
+      {
+        // Whole words only: both are real directives in the prompt. Ultrathink
+        // is per prompt, so it is set true or false every time.
+        ultrathink: Boolean(
+          hookInput && typeof hookInput.prompt === 'string' && /\bultrathink\b/i.test(hookInput.prompt)
+        ),
+      },
+      // Ultracode is Claude Code's own keyword trigger and it sticks for the
+      // session once used, so it is only ever set on here and otherwise
+      // carried forward. It is safe to read from the text now that every
+      // display reads the mark of the one session it describes.
+      hookInput && typeof hookInput.prompt === 'string' && /\bultracode\b/i.test(hookInput.prompt)
+        ? { ultracode: true }
+        : {}
+    ),
     now
   );
 
@@ -699,7 +910,7 @@ async function run(now, hookInput) {
   if (!view || !view.binding) {
     // One call, shared with the report. Building the view twice is how the
     // snapshot correction reached the report and never reached the hook.
-    const data = await usage.report(now, { sessionId });
+    const data = await usage.report(now, { sessionId, budgetMs: SCAN_BUDGET_MS });
     const binding = data.binding;
     view = {
       at: now,
@@ -716,6 +927,7 @@ async function run(now, hookInput) {
       })),
       snapshotAge: usage.formatDuration(data.snapshotAgeMs),
       binding: cacheableBinding(binding),
+      effortWarning: data.effortWarning || null,
     };
     writeCache(mergeCache(all, sessionId, view, KEEP_SESSIONS));
   }
@@ -732,7 +944,33 @@ async function run(now, hookInput) {
     binding.headroomMs <= RUNWAY_MENTION_MS;
   // Outside the cache on purpose: the tally moves after every reply.
   const found = tallyContext(tally.readState(), sessionId, now);
+  // Learning how the user writes, from the prompt that just arrived. Counters
+  // only, no model call, and it never speaks: what it knows is read back by
+  // /usage-limits:voice and used when the relay writes as them.
+  try {
+    if (hookInput && typeof hookInput.prompt === 'string') voice.observe(hookInput.prompt, now);
+  } catch (err) {
+    // Style is not worth a failed hook.
+  }
+  // This hook has just paid for a transcript scan, so the corrected figure is
+  // in hand. Leave it where the status line can read it: that line redraws far
+  // too often to scan for itself, and without this it shows the raw snapshot,
+  // which during a heavy session is wrong by tens of points in the flattering
+  // direction.
+  reading.record(binding, now, usage.isCodex() ? require('./codex.js').homeDir() : null);
+  const carry = relayState(now, hookInput, binding, sessionId);
+  // An instruction the user typed at /usage-limits:voice set. The learned
+  // traits are for writing AS them and stay out of the way; this is them
+  // saying how they want to be talked to, so it is said every time.
+  let voiceNote = null;
+  try {
+    voiceNote = voice.read().note;
+  } catch (err) {
+    voiceNote = null;
+  }
   return briefText({
+    relay: carry,
+    voiceNote,
     lastReply: found.lastReply,
     context: found.context,
     lastSession: found.lastSession,
@@ -754,6 +992,10 @@ async function run(now, hookInput) {
         : null,
     othersSummary: view.othersSummary,
     turnsLeft: view.turnsLeft,
+    effortWarning: view.effortWarning || null,
+    // Outside the cache: it is cheap, and it belongs to the other agent's
+    // clock rather than this session's.
+    codex: codexSummary(now),
     resetsIn:
       binding && !binding.stale && Number.isFinite(binding.resetsAt)
         ? usage.formatDuration(binding.resetsAt - now)
@@ -803,6 +1045,7 @@ module.exports = {
   describeWindow,
   summariseOthers,
   briefText,
+  codexSummary,
   tallyContext,
   LARGE_CONTEXT_TOKENS,
   settings,

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

@@ -0,0 +1,135 @@
+'use strict';
+// Reversible edits to Codex's top-level defaults. Never changes a running turn.
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const KEYS = ['model', 'model_reasoning_effort'];
+const EFFORTS = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+
+function scan(text) {
+  // Do not pretend a line editor is a full TOML parser.
+  if (text.includes('"""') || text.includes("'''")) throw new Error('Multiline TOML requires manual editing; config was not changed.');
+  const lines = text.match(/[^\n]*\n|[^\n]+$/g) || [];
+  const found = {};
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].replace(/^\uFEFF/, '');
+    if (/^\s*\[/.test(line)) break;
+    for (const key of KEYS) {
+      const re = new RegExp('^\\s*(?:' + key + '|"' + key + '"|\\x27' + key + '\\x27)\\s*=');
+      if (!re.test(line)) continue;
+      if (Object.hasOwn(found, key)) throw new Error('Duplicate top-level ' + key + '; config was not changed.');
+      if (!/=\s*(?:"(?:[^"\\]|\\.)*"|'[^']*')\s*(?:#.*)?(?:\r?\n)?$/.test(line))
+        throw new Error('Unsupported value for ' + key + '; config was not changed.');
+      found[key] = { index: i, line: lines[i] };
+    }
+  }
+  return { lines, found };
+}
+function rewrite(text, values) {
+  const { lines, found } = scan(text);
+  const prepend = [];
+  for (const [key, line] of Object.entries(values)) {
+    if (!KEYS.includes(key)) throw new Error('Invalid managed setting');
+    if (found[key]) lines[found[key].index] = line || '';
+    else if (line) prepend.push(line);
+  }
+  return prepend.join('') + lines.join('');
+}
+function read(file, fallback) {
+  try { return fs.readFileSync(file, 'utf8'); } catch (e) { if (e.code === 'ENOENT') return fallback; throw e; }
+}
+function atomic(file, text) {
+  const temp = file + '.' + process.pid + '.tmp';
+  try { fs.writeFileSync(temp, text, { encoding: 'utf8', mode: 0o600 }); fs.renameSync(temp, file); }
+  finally { if (fs.existsSync(temp)) fs.unlinkSync(temp); }
+}
+function checkState(state) {
+  if (!state) return;
+  if (state.version !== 1 || !state.previous || !state.applied) throw new Error('Unrecognized restore state; config was not changed.');
+  const keys = Object.keys(state.previous);
+  if (!keys.length || keys.some(k => !KEYS.includes(k)) || JSON.stringify(keys.sort()) !== JSON.stringify(Object.keys(state.applied).sort()))
+    throw new Error('Invalid restore state; config was not changed.');
+  for (const values of [state.previous, state.applied]) {
+    for (const [key, line] of Object.entries(values)) {
+      if (line === null) continue;
+      if (typeof line !== 'string') throw new Error('Invalid restore line');
+      const parsed = scan(line);
+      if (parsed.lines.length !== 1 || !parsed.found[key]) throw new Error('Invalid restore line');
+    }
+  }
+}
+function plan(text, options, state) {
+  checkState(state);
+  const { found } = scan(text);
+  const lineOf = key => found[key] ? found[key].line : null;
+  if (state) for (const [key, line] of Object.entries(state.applied)) {
+    if (lineOf(key) !== line) throw new Error(key + ' changed outside lowpower; review config and restore state before continuing.');
+  }
+  if (options.command === 'off') return { text: state ? rewrite(text, state.previous) : text, state: null };
+  const effort = options.effort || 'low';
+  if (!EFFORTS.includes(effort)) throw new Error('Unknown Codex effort: ' + effort);
+  if (options.model !== null && options.model !== undefined && !/^[a-zA-Z0-9][a-zA-Z0-9_.:/-]*$/.test(options.model))
+    throw new Error('Invalid Codex model identifier');
+  const wanted = { model_reasoning_effort: effort };
+  if (options.model) wanted.model = options.model;
+  const previous = { ...(state && state.previous) };
+  const applied = { ...(state && state.applied) };
+  const newline = text.includes('\r\n') ? '\r\n' : '\n';
+  for (const [key, value] of Object.entries(wanted)) {
+    if (!Object.hasOwn(previous, key)) previous[key] = lineOf(key);
+    applied[key] = key + ' = ' + JSON.stringify(value) + newline;
+  }
+  return { text: rewrite(text, applied), state: { version: 1, previous, applied } };
+}
+function main(args) {
+  if (!['status', 'on', 'off'].includes(args.command)) throw new Error('Expected status, on or off');
+  const dir = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  const file = path.join(dir, 'config.toml');
+  const stateFile = path.join(dir, 'usage-limits-lowpower.json');
+  const notice = 'Codex defaults only: new sessions. Active tasks, profiles and command-line overrides keep their own settings.';
+  // A lock serializes our writers. Other editors are detected before commit.
+  let lock;
+  if (args.command !== 'status' && !args.dryRun) {
+    fs.mkdirSync(dir, { recursive: true });
+    lock = fs.openSync(stateFile + '.lock', 'wx');
+  }
+  try {
+    const text = read(file, '');
+    const rawState = read(stateFile, null);
+    const state = rawState ? JSON.parse(rawState) : null;
+    checkState(state);
+    if (args.command === 'status') {
+      const { found } = scan(text);
+      console.log('Codex low power: ' + (state ? 'on' : 'off'));
+      for (const key of KEYS) console.log(found[key] ? found[key].line.trim() : key + ' = (unset)');
+      console.log(notice);
+      return 0;
+    }
+    const result = plan(text, args, state);
+    if (args.dryRun) {
+      console.log('Dry run; no files changed.\n' + notice);
+      const { found } = scan(result.text);
+      for (const key of KEYS) console.log(found[key] ? found[key].line.trim() : key + ' = (unset)');
+      return 0;
+    }
+    if (read(file, '') !== text || read(stateFile, null) !== rawState) throw new Error('Settings changed concurrently; retry.');
+    // Save recovery information before changing defaults; roll it back on error.
+    if (result.state) atomic(stateFile, JSON.stringify(result.state, null, 2) + '\n');
+    try {
+      if (result.text !== text) {
+        if (!state && fs.existsSync(file)) fs.copyFileSync(file, file + '.usage-limits-backup');
+        atomic(file, result.text);
+      }
+    } catch (e) {
+      if (rawState !== null) atomic(stateFile, rawState);
+      else if (fs.existsSync(stateFile)) fs.unlinkSync(stateFile);
+      throw e;
+    }
+    if (!result.state && fs.existsSync(stateFile)) fs.unlinkSync(stateFile);
+    console.log('Codex low power ' + args.command + '.\n' + notice);
+    return 0;
+  } finally {
+    if (lock !== undefined) { fs.closeSync(lock); fs.unlinkSync(stateFile + '.lock'); }
+  }
+}
+module.exports = { scan, rewrite, plan, main, EFFORTS };

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,