claude-usage-limits 1.11.6 → 1.13.0

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,27 @@ 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;
+
+// "fable" -> "Fable", the way the account names the window.
+function familyLabel(family) {
+  const name = String(family || '');
+  return name ? name.charAt(0).toUpperCase() + name.slice(1) : name;
+}
+
 // 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.
@@ -167,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() {
@@ -269,6 +291,10 @@ function pressure(window, now, config, turnsLeft) {
 const CACHED_BINDING_FIELDS = [
   'key',
   'label',
+  // The model family a per-model weekly is scoped to. Read by the line that
+  // says a model switch is the only thing that frees such a window, so it has
+  // to survive the cache like every other field the wording depends on.
+  'family',
   'applies',
   'percentUsed',
   'stale',
@@ -342,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';
@@ -446,6 +507,62 @@ 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
+  // to drop the effort and keep going, which spends the same window slower.
+  if (parts.family) {
+    sentences.push(
+      'That window counts ' + parts.family + ' turns only, so lowering effort does not free it: ' +
+        'switching model does. Use /model (or scripts/lowpower.js on --model <other>) for work ' +
+        'that does not need ' + parts.family + ', and keep this one for what does.'
+    );
+  }
   if (parts.othersSummary) sentences.push('Other windows: ' + parts.othersSummary + '.');
 
   // A window that is not binding can still be the expensive one to exhaust.
@@ -501,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
@@ -513,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 ' +
@@ -606,6 +776,62 @@ 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,
+      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 '';
 
@@ -620,15 +846,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
   );
 
@@ -674,7 +907,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,
@@ -691,6 +924,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));
   }
@@ -707,7 +941,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,
@@ -721,8 +981,18 @@ async function run(now, hookInput) {
         ? usage.formatDuration(now - binding.refusedAt)
         : null,
     binding,
+    // Named only while the window is actually tight: at 20 percent nobody
+    // needs telling how to free it.
+    family:
+      binding && binding.family && Number.isFinite(binding.percentUsed) && binding.percentUsed >= HALF_SPENT
+        ? familyLabel(binding.family)
+        : 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)
@@ -772,6 +1042,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 };