claude-usage-limits 1.19.0 → 1.24.0

package/skills/usage-limits/SKILL.md

@@ -275,6 +275,137 @@ The user can also ask any time with `/usage-limits:session`, or run
 `--sessions` for the history of recent sessions on this machine.
 
 
+## Budget modes
+
+How hard this plugin leans, and what it costs to say it. Four modes, set by the
+user and read by every hook:
+
+```
+node scripts/mode.js                 # which one, where it came from, what it changes
+node scripts/mode.js max             # set it
+node scripts/mode.js --list          # all four, and the aliases
+node scripts/mode.js --explain high  # one mode's full record
+```
+
+| mode | one line |
+| --- | --- |
+| `max` | fewest tokens that can still finish the job: one terse line, readings every ten minutes, silent when nothing a decision depends on has moved |
+| `high` | full capability, re-measured every two minutes mid-turn, and said only when the answer changes |
+| `standard` | what the plugin does today, unchanged. The default |
+| `off` | nothing injected at all; every hook returns before reading anything, including the end-of-reply tally |
+
+Aliases: `ultra`, `ultra-efficient`, `maxtoken`, `maxefficient` map to `max`;
+`smart`, `high-efficient` to `high`; `efficient`, `token-efficient`, `default`,
+`on` to `standard`; `none`, `quiet`, `silent`, `ignore` to `off`.
+
+**`normal` is not an alias for either.** To some people it means "the plugin
+working as usual" (`standard`) and to others "the plugin stays out of the way"
+(`off`) - opposite instructions, so a silent guess is wrong half the time. If
+the user says "normal", ask which they meant and say what each one does. The
+script answers the same way.
+
+`auto` picks from how full the binding window is - standard under 50 per cent
+used, high from 50 to 79, max at 80 or above - and always reports itself as
+what it resolved to (`auto -> max`). It reads the snapshot already on disk
+rather than scanning, because the mode has to be settled before anything
+expensive runs, and with no readable window it stays on `standard` rather than
+guessing. It never picks `off`: turning the plugin off is a decision a person
+makes.
+
+`off` means off, including at 100 per cent. That is deliberate. If the user
+wants one line at the wall and nothing else, `node scripts/mode.js off --guard 95`
+is it.
+
+Two rules hold in every mode, and they are not negotiable:
+
+- **A mode never lowers the quality of the work.** When things are tight you
+  change the ORDER of the work, never the amount or the quality. The savings
+  come from ceremony - speculative reads, re-reads, preamble, subagents nobody
+  needed, workflows that cost more context than they save.
+- **The modes govern the agent plane only**, and never write `settings.json`.
+
+### Two planes, and the conversation between them
+
+The **user plane** is `settings.json` (`model`, `effortLevel`), the `/effort`
+and `/model` pickers, and `lowpower.js`. It is the user saying what they want
+for themselves. It is theirs.
+
+The **agent plane** is the tier actually running this turn, and the tier of
+everything this turn spawns. That is what costs money.
+
+What is actually yours to move, stated exactly, because a claim beyond this
+would be a lie the user cannot check:
+
+- **The model on an `Agent` call is yours.** `model: "sonnet" | "opus" |
+  "haiku" | "fable"` on any Agent call, and it overrides both the agent
+  definition and the configured default. It is ignored for `subagent_type:
+  "fork"`, which always inherits the parent model.
+- **Model and effort inside a `Workflow` script are yours**, per `agent()`
+  call: `opts.model` and `opts.effort` (`low` | `medium` | `high` | `xhigh` |
+  `max`). The host's own advice is to omit `opts.model` unless you are
+  confident, and to use `opts.effort: 'low'` for mechanical stages - so lean on
+  effort rather than model when sizing what you spawn.
+- **Your own model and effort are NOT yours to change mid-session.** Nothing a
+  hook can emit changes them: there is no such field anywhere in the hook
+  output contract, and `PreModelSwitch` can only veto a switch someone else
+  started. `/model` and `/effort` are typed by a person and
+  `CLAUDE_CODE_EFFORT_LEVEL` is read at launch. So say the exact command in one
+  line and let the user run it. Never imply you changed it yourself.
+- `xhigh` and `max` are refused outright when thinking is disabled, so never
+  point at either without that being true.
+
+The two planes talk to each other, in both directions, through the
+conversation. The whole rule in one line:
+
+**You may RECOMMEND a user-plane change. You may MAKE one when asked. You may
+never make one unasked.**
+
+Recommending, when you do it:
+
+- **Evidence or silence.** Cite a measurement - what this account has actually
+  measured, from `usage.js --recommend`, the fit line in the budget briefing,
+  or `scripts/drift.js`. "Recommended" with no number is nagging.
+- **At most one per session**, and none at all in `off`. The plugin enforces
+  this; do not route around it.
+- **A declined recommendation is not raised again.** When the user says no,
+  record it - `node scripts/mode.js --decline` - and it is never volunteered
+  again, in this session or any later one. `--advice` shows what is pending.
+- **Name the exact command, the plane it changes, and when it takes effect.**
+
+When the user asks you to change something, or says **"change it back"**: read
+`node scripts/mode.js --history` first, say out loud what you are reverting and
+to what, then do it. Never infer a target that is not in the log. `node
+scripts/mode.js undo` reverses the last change the plugin owns and names it
+first; for a change to the user's own settings it names the command and leaves
+the file alone, because that plane is not the plugin's to write.
+
+The surprise to head off, every time: **a user-plane change does not move the
+session already running.** If the user says "turn low power on" and you do it,
+nothing about this session changes - `lowpower.js` says so itself ("Applies to
+new sessions. For the session you are in, run /effort X"). Relay that in your
+own words whenever you make one, and the same in reverse: putting the baseline
+back does not restore this session's tier either.
+
+### Bounds the user can set
+
+```
+node scripts/mode.js --floor sonnet/medium   # never point below this, even in max
+node scripts/mode.js --ceiling opus/xhigh    # nor above it, even on the hard part
+node scripts/mode.js --pin                   # do not self-switch at all: report only
+```
+
+Under `--pin` the plugin reports the gap between the baseline and what is
+running and suggests nothing. Respect it in your own words too: report, do not
+switch.
+
+### Stepping back up
+
+The efficient modes are two-directional, and that matters more than it sounds.
+Having dropped to a cheap tier for a mechanical stretch, say so when the work
+turns hard again and point back at the baseline. A one-way ratchet down is how
+a long session quietly degrades, which is the thing the quality rule forbids.
+
+
 ## 4. Low power
 
 Two halves, and the second one is the half that actually binds.
@@ -404,41 +535,48 @@ waste at 10 per cent used exactly as much as at 80; the only difference is that
 at 80 somebody notices.
 
 It cannot judge how hard your work is. You can. So when you see it, look at what
-is actually in front of you and take one of three levers yourself, saying which
-in one line:
+is actually in front of you and reach for one of three levers, saying which in
+one line. Two of them are yours to pull; the first is not.
 
 1. **Drop the effort** for that stretch - a rename, a docs pass, running tests,
-   applying a fix you have already worked out.
-2. **Hand the stretch to a cheaper model**, and keep the dear one for the
-   decisions that need it.
+   applying a fix you have already worked out. `/effort` and `settings.json` are
+   the user's own baseline, so this one you **offer**: name the command, say why
+   the stretch does not need the tier, and leave the pulling of it to them.
+2. **Hand the stretch to a cheaper model.** Your own model is the user's setting
+   too, so say that in one line rather than switching - but the model on
+   anything you SPAWN is entirely yours: an Agent call takes a model, and a
+   Workflow's `agent()` takes a model and an effort. Size those to the stage.
 3. **Do less of it at this setting** - a fan-out multiplies the setting across
-   every agent, so six agents at ultra is six ultra turns, not one.
+   every agent, so six agents at ultra is six ultra turns, not one. Yours.
 
 Put it back when the work gets hard again. The question is asked once per
 setting per session, not every prompt, and never at all unless there is a real
 measured comparison behind it - a ratio from a price list would have you drop
 effort on a hunch and call it evidence.
 
-**This is a lever you may pull yourself, not only an emergency exit.** Use it
-whenever the current setting is dearer than the work in front of you needs,
-without being asked and long before any window is tight: a mechanical rename,
-a docs pass or a mass find-and-replace does not need the model and effort a
-hard design decision does. Drop it for that stretch, say in one line that you
-did and why, and put it back when the work gets hard again. An agent that only
-ever reads this as a wall notice runs every trivial turn at the top setting and
-then wonders where the window went.
+**This is worth raising early, not only at the wall.** Say it whenever the
+current setting is dearer than the work in front of you needs, long before any
+window is tight: a mechanical rename, a docs pass or a mass find-and-replace
+does not need the model and effort a hard design decision does. An agent that
+only ever reads this as a wall notice runs every trivial turn at the top setting
+and then wonders where the window went.
+
+**And "offer it" is one line, not a stop.** Naming the lever and carrying on is
+the whole action. Waiting for an answer before doing the work would cost more
+than the tier ever did.
 
 The budget line does this arithmetic for you. Once the binding window is half
 gone it says which lever applies, and at the wall it says outright that you are
 not out of budget and must not stop as though you were. When it does, the
-sequence is: switch, say in one line that you switched and why, carry on with
-the whole request at full quality.
+sequence is: say in one line which command frees it and why, and carry on with
+the whole request at full quality. A per-model weekly is not the account's
+budget, and treating it as one is the error.
 
 This is written down because it was got wrong. A session ended with the Fable
 weekly at 89 per cent and the line saying the budget was nearly gone - while the
 5-hour sat at 46 and every other model on the account was untouched. One command
-would have carried it on. Stopping there was not caution; it was quitting with a
-reason that sounded like one.
+would have carried it on, and naming that command costs a line. Stopping there
+was not caution; it was quitting with a reason that sounded like one.
 
 Only when the switch is genuinely unavailable - no other window has room, or the
 user has ruled it out - does the checkpoint below apply.
@@ -482,6 +620,32 @@ which files are mid-change, what must be verified before anything is built on
 it. It is delivered as a prompt, so an instruction beats a summary. If nothing
 is written, the relay falls back to the outstanding todo list, which is worse.
 
+**It arms at the end of a reply, not in the middle of one.** Crossing the
+threshold no longer schedules anything by itself: the relay waits for the reply
+to finish, so what it carries is work that reached a boundary rather than a
+snapshot of an interruption. Past the backstop (95 per cent by default) it stops
+waiting and arms anyway, because a completion that never comes - the limit cut
+the reply off mid-sentence - is a relay that was never armed at all. That is
+what "waiting for this reply to finish before arming" means when the budget line
+says it, and it is not an error. `relay armon threshold` restores the old
+behaviour.
+
+**Being offline is not failing.** Before it launches anything the wake checks it
+can actually reach the API, and a machine that cannot is held, not spent: it
+retries on a backoff for hours rather than burning the relay on a launch that
+could not work. This exists because it happened - a relay woke on time, said
+`SSL certificate hostname mismatch` 1.5 seconds later, recorded a failure and
+deleted itself, and a night's work was lost to a router being off. A failed
+launch is also classified now: the network and a busy service buy another
+window, an invalid key or a missing CLI does not, because retrying those would
+waste the window and saying "retrying" would be a lie.
+
+Run `relay doctor` before trusting it with anything. It checks the things that
+fail silently hours later - a CLI that moved, a permission mode nobody set, a
+machine whose power plan forbids wake timers, a scheduled task this account
+cannot register, no continuation written, no network - and says which would
+bite. Every resumed run's full output is kept: `relay log --run`.
+
 The relay is off unless the user turned it on, and it only arms while there is
 an unfinished todo list or an approved plan to carry. Do not turn it on for
 them, and do not promise behaviour it does not have:
@@ -490,6 +654,8 @@ them, and do not promise behaviour it does not have:
   input to a shell on purpose; the relay uses it only to tell whether somebody
   is at the keyboard, and to show a banner.
 - In `notify` mode — the default — it raises a notification and starts nothing.
+- The resumed run opens in a window you can see. `relay show off` hides it; the
+  output is kept either way.
 - In `resume` mode it runs the CLI itself. A headless resume does **not**
   inherit the session's permission mode, so unless one was set the resumed run
   will sit waiting for an approval nobody is there to give.
@@ -540,6 +706,14 @@ of it.
 
 ## Running under Codex
 
+One difference that matters for the budget modes. Every entry in Codex's
+`hooks.json` carries an `additionalContextLimit` - a per-hook cap on how much
+context a hook may inject, which Claude Code has no equivalent of. A long
+briefing can therefore be truncated there without a word. If a line looks cut
+off under Codex, that is why: `node scripts/mode.js max` keeps it to one line,
+and `high` is the verbose one.
+
+
 Everything above works the same. The numbers come from a different place and
 one thing about how they arrive is different, and both are worth knowing.
 
@@ -654,6 +828,7 @@ stop.
 | `scripts/host.js` | Works out which agent this is running inside, so one host's percentages are never reported against the other's turns. |
 | `scripts/codex.js` | The Codex reader: the meter and the pace out of `~/.codex/sessions`, plus the live `--refresh` call. |
 | `scripts/install-codex-hook.js` | `status`, `on`, `off`. Installs the Codex-side instruction, which Claude Code does not need. |
+| `scripts/mode.js` | The budget mode: no arguments to report it, `max`/`high`/`standard`/`off` to set it, `auto`, `off --guard 95`, `--list`, `--explain <name>`, `--floor`/`--ceiling`/`--pin`, `--baseline`, `--advice`/`--no-advice`, `--history`, `undo`, `--ledger`. Reads settings.json and never writes it. |
 | `scripts/lowpower.js` | `status`, `on`, `off`. Restores what it replaced. Claude Code only. |
 | `scripts/recommend.js` | The chooser behind `usage.js --recommend`: posture, then the effort and model commands for each lever. Not meant to be called by hand. |
 | `references/tactics.md` | Every lever that lowers cost, and why it works. |
@@ -661,8 +836,10 @@ stop.
 | `scripts/statusline.js` | `status`, `on`, `off`. Puts the bars under the prompt and restores what was there. |
 | `scripts/feed.js` | The status line command Claude Code runs. Not meant to be called by hand. |
 | `scripts/live.js` | The usage reading itself, taken the way Claude Code takes it for `/usage`, kept in `usage-limits-live.json` where `collect()` prefers it when newer than the cache. |
+| `scripts/drift.js` | How wrong the reading was: each correction written down against the one it replaced. Run it with no arguments for the median and worst gap measured so far, `--json` for the fields. Answer "how far behind does this plugin actually run" from here rather than from memory. |
 | `scripts/view.js`, `scripts/bars.js`, `scripts/activity.js` | The display model, the drawing in Claude's colours, and the working/idle marks the hooks leave for the panel. Not meant to be called by hand. |
-| `scripts/relay.js` | The relay: `status`, `on`/`off`, `at N`, `grace N`, `mode notify\|resume`, `permission MODE`, `thinking off\|resume\|always`, `note "<text>"`, `cancel`, `log`. |
+| `scripts/relay.js` | The relay: `status`, `on`/`off`, `at N`, `grace N`, `mode notify\|resume`, `permission MODE`, `thinking off\|resume\|always`, `armon threshold\|completion`, `backstop N`, `show on\|off`, `onfailure rearm\|stop`, `rearms N`, `offline N`, `doctor`, `note "<text>"`, `cancel`, `log [--run]`. |
+| `scripts/net.js` | Can this machine reach the API, and was a failed run the network's fault. Three probes, TLS-interception detection, and the backoff the offline retries use. |
 | `scripts/wake.js` | What the scheduler runs after the reset: re-checks the meter, then notifies or resumes. Never called by hand. |
 | `scripts/voice.js` | The local writing profile: `show`, `card`, `set "<instruction>"`, `clear`, `off`/`on`, `forget`. |
 | `references/how-it-works.md` | Where the numbers come from and where they are soft. |

package/skills/usage-limits/references/tactics.md

@@ -87,15 +87,46 @@ reason, if none of them are in use.
 
 Cache reads are ten times cheaper than fresh input, and the cache matches on
 an exact prefix. Any byte that changes early invalidates everything after it.
-Things that invalidate it mid-session:
-
-- switching models
-- editing `CLAUDE.md` or project settings
-- connecting or disconnecting an MCP server
-- changing the tool set
-
-None of these are forbidden. Just do them at a session boundary instead of in
-the middle of a long run.
+What actually invalidates it mid-session:
+
+- **switching models** - each model has its own cache, so the next request
+  re-reads the whole conversation even though the content is identical
+- **changing the effort level** - on most models each effort level has its own
+  cache too. This one matters here because dropping effort is the saving this
+  plugin recommends most often. It is still worth doing, but it is not free
+  mid-session: on a large context the one-off rebuild can cost more than a few
+  cheaper turns save. Choose effort at the START of a session where you can
+- **turning on fast mode** - it adds a request header that is part of the cache key
+- **connecting or disconnecting an MCP server, but only when its tools sit in
+  the prefix.** With tool search - the default on supported models - a server
+  connecting, disconnecting or changing its tool list only appends, and the
+  cached prefix survives
+- **enabling or disabling a plugin that provides MCP servers**, by the same
+  rule. A plugin ships skills, commands, agents and hooks by appending them,
+  and those never invalidate anything
+- **adding or removing a bare tool-name deny rule** (`Bash`, `WebFetch`), which
+  takes the tool out of the system prompt. Scoped rules like `Bash(rm *)` do not
+- **compacting**, by design, and **upgrading Claude Code**
+
+What does NOT invalidate it, despite being widely believed to:
+
+- **editing `CLAUDE.md` mid-session.** It is read once at session start and held
+  in memory. The edit does not invalidate the cache - and it also does not
+  apply, until `/clear`, `/compact` or a restart
+- editing files in the repository, changing permission mode, changing output
+  style, invoking a skill or command, and `/recap`
+
+None of the invalidating ones are forbidden. Just do them at a session boundary
+instead of in the middle of a long run.
+
+**`/rewind` rather than `/compact`** when abandoning a path: it truncates back to
+a prefix that is already cached, where compaction builds a new one and pays a
+summarisation call to do it.
+
+**Cache scope is one machine and one directory.** Parallel sessions in the same
+directory read each other cache; different directories do not - and that
+includes two worktrees of the same repository, which is a real and unobvious
+cost of isolating agents that way.
 
 ### 6. Batch tool calls
 

package/skills/usage-limits/scripts/agy-hook.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+'use strict';
+
+// The Antigravity entry point.
+//
+// Antigravity (and the `agy` CLI behind it) has a lifecycle-hook system that is
+// close to Claude Code's in spirit and different from it in every detail that
+// matters to a script:
+//
+//   - Events are PreInvocation, PostInvocation, PreToolUse, PostToolUse and
+//     Stop. PreInvocation is the one that corresponds to UserPromptSubmit.
+//   - Every payload is protojson, so the keys are camelCase: conversationId,
+//     workspacePaths, transcriptPath, modelName, stepIdx, invocationNum.
+//   - Output is JSON on stdout, and each event has its own shape. Plain text
+//     on stdout is not context; it is a parse failure, and a parse failure is
+//     silent. That is the whole reason this file exists rather than pointing
+//     Antigravity at brief.js and hoping.
+//   - PreToolUse takes a decision of allow, deny, ask or force_ask.
+//
+// The contract is documented on the machine itself, in the built-in
+// agy-customizations skill at
+// ~/.gemini/antigravity-cli/builtin/skills/agy-customizations/docs/hooks.md,
+// which is where these shapes were read from rather than guessed.
+//
+//   node agy-hook.js --event PreInvocation
+//   node agy-hook.js --event PreToolUse
+//
+// Nothing here ever exits non-zero. Antigravity runs hooks synchronously and
+// they block the agent loop, so a hook that fails is a hook that stops the
+// user's work, and no budget figure is worth that.
+
+const usage = require('./usage.js');
+const host = require('./host.js');
+const mode = require('./mode.js');
+const ceiling = require('./ceiling.js');
+const brief = require('./brief.js');
+
+const EVENTS = ['PreInvocation', 'PostInvocation', 'PreToolUse', 'PostToolUse', 'Stop'];
+
+function eventFrom(argv, input) {
+  const args = argv || [];
+  const at = args.indexOf('--event');
+  if (at !== -1 && EVENTS.includes(args[at + 1])) return args[at + 1];
+  // Antigravity does not name the event in the payload, so the shape is the
+  // only other evidence. toolCall is only ever present on the two tool events,
+  // and only PreToolUse can act on one.
+  if (input && input.toolCall) return 'PreToolUse';
+  if (input && input.terminationReason !== undefined) return 'Stop';
+  if (input && input.invocationNum !== undefined) return 'PreInvocation';
+  return null;
+}
+
+function readInput() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve(null);
+    let raw = '';
+    let settled = false;
+    const done = () => {
+      if (settled) return;
+      settled = true;
+      try {
+        resolve(raw ? JSON.parse(raw) : null);
+      } catch (err) {
+        resolve(null);
+      }
+    };
+    const timer = setTimeout(done, 500);
+    if (timer.unref) timer.unref();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on('end', done);
+    process.stdin.on('error', done);
+  });
+}
+
+// The tool name, as Antigravity spells it.
+//
+// Tool names there are the step type lowercased with the CORTEX_STEP_TYPE_
+// prefix removed, so they are snake_case: run_command, view_file, browser_*.
+// ceiling.js matches both spellings, so nothing has to be translated here.
+function toolNameOf(input) {
+  if (!input || !input.toolCall) return '';
+  return String(input.toolCall.name || '');
+}
+
+// The cheapest percentage worth enforcing against.
+//
+// Antigravity does not publish remaining quota anywhere this can read - see
+// collectGemini in usage.js, which says so rather than inventing a number - so
+// on a Gemini host this is usually null and the ceiling never fires. It is
+// still wired, because the same hook file runs when USAGE_LIMITS_HOST names a
+// host that DOES have a meter, and because a ceiling that silently does
+// nothing on the day Antigravity starts publishing one would be worse.
+function percentNow(now) {
+  let worst = null;
+  try {
+    const snapshot = usage.collect(now);
+    const utilization = snapshot && snapshot.utilization;
+    if (utilization && typeof utilization === 'object') {
+      for (const key of Object.keys(utilization)) {
+        const window = utilization[key];
+        if (!window || typeof window !== 'object') continue;
+        const value = Number(window.utilization);
+        if (Number.isFinite(value) && (worst === null || value > worst)) worst = value;
+      }
+    }
+  } catch (err) {
+    // No reading is a reason not to enforce, never a reason to throw.
+  }
+  return worst;
+}
+
+async function run(now, input, argv) {
+  const event = eventFrom(argv, input);
+  if (!event) return {};
+
+  usage.setHost(host.GEMINI);
+  const sessionId = input && input.conversationId ? String(input.conversationId) : null;
+  const budget = mode.forSession({ sessionId });
+  if (budget.policy.briefStyle === 'none') return {};
+
+  if (event === 'PreToolUse') {
+    const tool = toolNameOf(input);
+    if (!ceiling.isMultiplier(tool)) return {};
+    const at = ceiling.assess({ percent: percentNow(now), state: budget.state, env: process.env });
+    const call = ceiling.verdict(at, tool);
+    if (call.decision !== 'deny') return {};
+    return { decision: 'deny', reason: call.reason };
+  }
+
+  if (event === 'PreInvocation') {
+    // The one place a budget line can reach the model. Antigravity takes it as
+    // an injected step rather than as stdout text; an ephemeralMessage is a
+    // transient system message, which is exactly what a per-turn figure is.
+    let text = '';
+    try {
+      text = await brief.run(now, input);
+    } catch (err) {
+      text = '';
+    }
+    const warning = ceiling.warning(
+      ceiling.assess({ percent: percentNow(now), state: budget.state, env: process.env })
+    );
+    const message = [text, warning].filter(Boolean).join(' ');
+    return message ? { injectSteps: [{ ephemeralMessage: message }] } : { injectSteps: [] };
+  }
+
+  // PostToolUse, PostInvocation and Stop all want an object and none of them
+  // wants anything from this plugin. Deliberately NOT returning
+  // terminationBehavior on PostInvocation, and NOT returning decision
+  // "continue" on Stop: both would keep the loop running, which is the
+  // opposite of what a budget plugin should ever do to a user's quota.
+  return {};
+}
+
+if (require.main === module) {
+  readInput()
+    .then((input) => run(Date.now(), input, process.argv.slice(2)))
+    .then(
+      (result) => {
+        process.stdout.write(JSON.stringify(result || {}) + '\n');
+        process.exit(0);
+      },
+      () => {
+        // Hooks block the agent loop here, so a failure has to be silent and
+        // well formed rather than loud.
+        process.stdout.write('{}\n');
+        process.exit(0);
+      }
+    );
+}
+
+module.exports = { EVENTS, eventFrom, toolNameOf, percentNow, run };