aqua-wasted 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mehdev67
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# aqua-wasted 💧
+
+Every token your AI burns runs in a data center that drinks fresh water to stay cool. **aqua-wasted** puts that hidden cost right in your Claude Code statusline, so you watch it climb while you work.
+
+```
+⬆ /build │ Opus 4.7 │ myproject  💧 Aqua wasted 2 130 ml (≈ 4 bottles)
+```
+
+It is a fun, slightly guilty little awareness tool. The number is real enough to make you think, and grounded in published research (sources below).
+
+## Install
+
+One command, zero dependencies. Claude Code already ships Node, so this just works.
+
+```bash
+npx aqua-wasted install
+```
+
+That drops a tiny script into `~/.claude/aqua-wasted/` and wires your `~/.claude/settings.json`. Then run `/statusline` in Claude Code or start a new session.
+
+Already have a statusline? aqua-wasted detects it and runs it first, then appends the water segment after it. Your line is kept, not replaced.
+
+Want it scarier or quieter:
+
+```bash
+npx aqua-wasted install --spicy          # bigger numbers, still under the studied maximum
+npx aqua-wasted install --conservative   # honest figures for modern efficient models
+npx aqua-wasted install --unit=dl         # ml is the default, dl and L also work
+npx aqua-wasted install --no-bottles      # drop the bottle count
+```
+
+## Uninstall
+
+```bash
+npx aqua-wasted uninstall
+```
+
+This restores the statusline you had before, or removes ours if there was none. Your settings are backed up to `settings.json.bak-<timestamp>` on every install, just in case.
+
+## The lifetime brag card
+
+See the total water across every session you have ever run:
+
+```bash
+npx aqua-wasted card --unit=L
+```
+
+```
+  💧 aqua-wasted lifetime report
+  ════════════════════════════════════════════
+  sessions counted : 312
+  tokens burned    : 84 200 000
+  water wasted     : 2 526 L
+  bottles          : 5 052 (500 ml each)
+  showers          : 36.1
+  ════════════════════════════════════════════
+```
+
+## How the number works
+
+Token usage is summed straight from your Claude Code session transcript, so it reflects everything the session has actually generated and read. Generating tokens costs far more water than reading context, so output and input tokens are weighted separately. Three tiers ship in the box:
+
+| Tier | output token | input token | basis |
+|------|--------------|-------------|-------|
+| conservative | 0.01 ml | 0.002 ml | modern, efficient 2025 models |
+| headline (default) | 0.03 ml | 0.0075 ml | maps 1:1 to the UC Riverside figures |
+| spicy | 0.1 ml | 0.025 ml | GPT 4 era, hot region, still below the studied maximum |
+
+Edit `~/.claude/aqua-wasted/config.json` any time to change tier, unit, label, emoji, or color.
+
+## True comparisons you can quote
+
+- A 100 word AI email pours out about a bottle of water (519 ml), straight from the UC Riverside and Washington Post reporting.
+- Roughly 16,500 generated tokens drink one 500 ml bottle.
+- One million tokens is about 30 liters, two full kitchen sinks.
+- A heavy coding week of around 2.5 million tokens is about 75 liters, one full shower.
+- Training GPT 3 once evaporated 700,000 liters of clean freshwater, before anyone typed a single prompt.
+
+## Honest disclaimer
+
+These water figures are rough, illustrative estimates. Actual water use per token varies enormously by model, data center location, cooling technology, electricity grid, and season, easily by ten times or more, and includes both the on site cooling water and the water used to generate the electricity. They are meant to raise awareness of a real but hard to pin down cost, not to be a precise measurement.
+
+Primary sources:
+
+- Li, Yang, Islam, Ren. "Making AI Less Thirsty." UC Riverside, 2023, peer reviewed in Communications of the ACM, 2025. https://arxiv.org/abs/2304.03271
+- Washington Post, "AI is exhausting the power grid," September 2024.
+- Epoch AI, "How much energy does ChatGPT use?", 2025.
+
+## Use as a Claude Code plugin
+
+Prefer the plugin browser:
+
+```
+/plugin marketplace add mehdev67/aqua-wasted
+/plugin install aqua-wasted@aqua-wasted
+```
+
+Then run the bundled command to wire it up:
+
+```
+/aqua-wasted
+```
+
+## License
+
+MIT. Use it, fork it, make the planet a tiny bit more visible.

package/bin/cli.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+'use strict';
+
+// aqua-wasted CLI: install | uninstall | status | card | help
+// Safely wires the statusline into Claude Code and renders a shareable card.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const core = require('../statusline.js');
+
+const HOME = os.homedir();
+const CLAUDE_DIR = path.join(HOME, '.claude');
+const SETTINGS = path.join(CLAUDE_DIR, 'settings.json');
+const INSTALL_DIR = path.join(CLAUDE_DIR, 'aqua-wasted');
+const RUNTIME = path.join(INSTALL_DIR, 'statusline.js');
+const CONFIG = path.join(INSTALL_DIR, 'config.json');
+const PKG_RUNTIME = path.join(__dirname, '..', 'statusline.js');
+const PROJECTS_DIR = path.join(CLAUDE_DIR, 'projects');
+
+// --- small helpers ----------------------------------------------------------
+
+function readJson(file, fallback) {
+  try {
+    if (!fs.existsSync(file)) return fallback;
+    const raw = fs.readFileSync(file, 'utf8');
+    if (!raw.trim()) return fallback;
+    return JSON.parse(raw);
+  } catch (e) {
+    return undefined; // signals a parse failure to the caller
+  }
+}
+
+function atomicWrite(file, contents) {
+  const tmp = file + '.tmp-' + process.pid;
+  fs.writeFileSync(tmp, contents);
+  fs.renameSync(tmp, file);
+}
+
+function ourCommand() {
+  return 'node "' + RUNTIME + '"';
+}
+
+function isOurCommand(cmd) {
+  return typeof cmd === 'string' && cmd.indexOf('aqua-wasted') !== -1;
+}
+
+function parseFlags(argv) {
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--spicy') flags.tier = 'spicy';
+    else if (a === '--conservative') flags.tier = 'conservative';
+    else if (a === '--headline') flags.tier = 'headline';
+    else if (a === '--no-bottles') flags.bottles = false;
+    else if (a === '--no-color') flags.color = false;
+    else if (a === '--no-chain') flags.noChain = true;
+    else if (a.startsWith('--tier=')) flags.tier = a.slice(7);
+    else if (a.startsWith('--unit=')) flags.unit = a.slice(7);
+    else if (a.startsWith('--label=')) flags.label = a.slice(8);
+    else if (a.startsWith('--locale=')) flags.locale = a.slice(9);
+    else if (a.startsWith('--color=')) flags.color = a.slice(8);
+  }
+  return flags;
+}
+
+// --- commands ---------------------------------------------------------------
+
+function install(argv) {
+  const flags = parseFlags(argv);
+
+  const settings = readJson(SETTINGS, {});
+  if (settings === undefined) {
+    console.error('aqua-wasted: could not parse ' + SETTINGS + '. It may contain comments or be invalid JSON.');
+    console.error('Nothing was changed. Add this block manually instead:');
+    console.error('  "statusLine": { "type": "command", "command": ' + JSON.stringify(ourCommand()) + ' }');
+    process.exit(1);
+  }
+
+  // Detect an existing statusLine so we can chain rather than clobber it.
+  let chain = null;
+  const existing = settings.statusLine;
+  if (existing && existing.type === 'command' && existing.command && !isOurCommand(existing.command)) {
+    if (!flags.noChain) {
+      chain = existing.command;
+      console.log('Found an existing statusLine. aqua-wasted will run it first and append after it.');
+    } else {
+      console.log('Found an existing statusLine. Replacing it (--no-chain).');
+    }
+  } else if (existing && existing.type !== 'command' && !isOurCommand(JSON.stringify(existing))) {
+    console.log('Found a non command statusLine. Leaving it and adding ours on top.');
+  }
+
+  // Write runtime + config into a stable location, independent of the npx cache.
+  fs.mkdirSync(INSTALL_DIR, { recursive: true });
+  fs.copyFileSync(PKG_RUNTIME, RUNTIME);
+
+  const cfg = Object.assign({}, core.DEFAULT_CONFIG, {
+    tier: flags.tier || core.DEFAULT_CONFIG.tier,
+    unit: flags.unit || core.DEFAULT_CONFIG.unit,
+    bottles: flags.bottles === false ? false : core.DEFAULT_CONFIG.bottles,
+    color: flags.color === false ? false : flags.color || core.DEFAULT_CONFIG.color,
+    label: flags.label || core.DEFAULT_CONFIG.label,
+    locale: flags.locale || core.DEFAULT_CONFIG.locale,
+    chain: chain,
+  });
+  if (!core.TIERS[cfg.tier]) {
+    console.error('aqua-wasted: unknown tier "' + cfg.tier + '". Use conservative, headline, or spicy.');
+    process.exit(1);
+  }
+  atomicWrite(CONFIG, JSON.stringify(cfg, null, 2) + '\n');
+
+  // Back up settings, then patch only the statusLine key.
+  if (fs.existsSync(SETTINGS)) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    fs.copyFileSync(SETTINGS, SETTINGS + '.bak-' + stamp);
+  } else {
+    fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+  }
+  settings.statusLine = { type: 'command', command: ourCommand(), padding: 0 };
+  atomicWrite(SETTINGS, JSON.stringify(settings, null, 2) + '\n');
+
+  console.log('');
+  console.log('  ' + core.renderSegment({ output: 9000, input: 60000, cacheCreation: 0, cacheRead: 0 }, cfg));
+  console.log('');
+  console.log('aqua-wasted installed. Tier: ' + cfg.tier + ', unit: ' + cfg.unit + '.');
+  console.log('Run /statusline in Claude Code or start a new session to see it.');
+  console.log('Config: ' + CONFIG);
+}
+
+function uninstall() {
+  const settings = readJson(SETTINGS, {});
+  if (settings === undefined) {
+    console.error('aqua-wasted: could not parse ' + SETTINGS + '. Remove the statusLine block manually.');
+    process.exit(1);
+  }
+  const cfg = readJson(CONFIG, {}) || {};
+  const sl = settings.statusLine;
+  if (sl && sl.command && isOurCommand(sl.command)) {
+    if (cfg.chain) {
+      settings.statusLine = { type: 'command', command: cfg.chain };
+      console.log('Restored your previous statusLine.');
+    } else {
+      delete settings.statusLine;
+      console.log('Removed the aqua-wasted statusLine.');
+    }
+    atomicWrite(SETTINGS, JSON.stringify(settings, null, 2) + '\n');
+  } else {
+    console.log('No aqua-wasted statusLine found in settings. Nothing changed.');
+  }
+  try {
+    fs.rmSync(INSTALL_DIR, { recursive: true, force: true });
+  } catch (e) {
+    // leave it; not fatal
+  }
+  console.log('Done. Your settings backups (.bak-*) were kept.');
+}
+
+function status() {
+  const cfg = readJson(CONFIG, undefined);
+  const settings = readJson(SETTINGS, {});
+  const installed =
+    settings && settings.statusLine && isOurCommand(settings.statusLine.command || '');
+  console.log('aqua-wasted status');
+  console.log('  installed: ' + (installed ? 'yes' : 'no'));
+  if (cfg) {
+    console.log('  tier:      ' + cfg.tier);
+    console.log('  unit:      ' + cfg.unit);
+    console.log('  bottles:   ' + cfg.bottles);
+    console.log('  chained:   ' + (cfg.chain ? 'yes' : 'no'));
+  }
+  console.log('  config:    ' + CONFIG);
+}
+
+// Walk ~/.claude/projects for every transcript and sum lifetime tokens.
+function lifetimeTotals() {
+  const totals = { input: 0, cacheCreation: 0, cacheRead: 0, output: 0 };
+  let files = 0;
+  function walk(dir) {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (e) {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path.join(dir, ent.name);
+      if (ent.isDirectory()) walk(full);
+      else if (ent.isFile() && ent.name.endsWith('.jsonl')) {
+        files++;
+        const t = core.sumTokensFromTranscript(full);
+        totals.input += t.input;
+        totals.cacheCreation += t.cacheCreation;
+        totals.cacheRead += t.cacheRead;
+        totals.output += t.output;
+      }
+    }
+  }
+  walk(PROJECTS_DIR);
+  return { totals: totals, files: files };
+}
+
+function card(argv) {
+  const flags = parseFlags(argv);
+  const cfg = Object.assign({}, core.DEFAULT_CONFIG, readJson(CONFIG, {}) || {}, {
+    tier: flags.tier || (readJson(CONFIG, {}) || {}).tier || core.DEFAULT_CONFIG.tier,
+    unit: flags.unit || 'auto',
+  });
+  const res = lifetimeTotals();
+  const ml = core.computeWaterMl(res.totals, cfg.tier);
+  const liters = ml / 1000;
+  const bottles = Math.round(ml / core.BOTTLE_ML);
+  const showers = liters / 70; // a typical shower is roughly 70 liters
+  const tokens =
+    res.totals.input + res.totals.cacheCreation + res.totals.cacheRead + res.totals.output;
+
+  const nf = (n, d) => core.formatNumber(n, d, cfg.locale);
+  const line = '  ' + '═'.repeat(44);
+  console.log('');
+  console.log('  \u{1F4A7} aqua-wasted lifetime report');
+  console.log(line);
+  console.log('  sessions counted : ' + nf(res.files, 0));
+  console.log('  tokens burned    : ' + nf(tokens, 0));
+  console.log('  water wasted     : ' + core.formatWater(ml, cfg.unit, cfg.locale));
+  console.log('  bottles          : ' + nf(bottles, 0) + ' (500 ml each)');
+  console.log('  showers          : ' + nf(showers, 1));
+  console.log(line);
+  console.log('  tier: ' + cfg.tier + '. Rough illustrative estimate. See the README.');
+  console.log('');
+}
+
+function help() {
+  console.log('aqua-wasted: turn your Claude Code token usage into water wasted.');
+  console.log('');
+  console.log('Usage:');
+  console.log('  npx aqua-wasted install [--spicy|--conservative] [--unit=ml|dl|L|auto] [--no-bottles] [--no-chain]');
+  console.log('  npx aqua-wasted uninstall');
+  console.log('  npx aqua-wasted status');
+  console.log('  npx aqua-wasted card [--unit=L]');
+  console.log('');
+  console.log('Install drops the statusline into ~/.claude/aqua-wasted/ and wires settings.json.');
+  console.log('If you already have a statusLine, it is chained, not replaced.');
+}
+
+// --- dispatch ---------------------------------------------------------------
+
+const [, , cmd, ...rest] = process.argv;
+switch (cmd) {
+  case 'install':
+    install(rest);
+    break;
+  case 'uninstall':
+  case 'remove':
+    uninstall();
+    break;
+  case 'status':
+    status();
+    break;
+  case 'card':
+    card(rest);
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+  case undefined:
+    help();
+    break;
+  default:
+    console.error('aqua-wasted: unknown command "' + cmd + '"');
+    help();
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "aqua-wasted",
+  "version": "0.1.0",
+  "description": "A Claude Code statusline that turns your token usage into the cooling water your AI session burns.",
+  "bin": {
+    "aqua-wasted": "bin/cli.js"
+  },
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "statusline.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "card": "node bin/cli.js card",
+    "demo": "echo '{\"transcript_path\":\"\",\"context_window\":{\"current_usage\":{\"output_tokens\":9000,\"input_tokens\":60000}}}' | node statusline.js"
+  },
+  "keywords": [
+    "claude-code",
+    "statusline",
+    "tokens",
+    "water",
+    "sustainability",
+    "awareness",
+    "cli"
+  ],
+  "author": "mehdev67",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mehdev67/aqua-wasted.git"
+  },
+  "homepage": "https://github.com/mehdev67/aqua-wasted#readme",
+  "bugs": {
+    "url": "https://github.com/mehdev67/aqua-wasted/issues"
+  },
+  "dependencies": {}
+}

package/statusline.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+'use strict';
+
+// aqua-wasted: a Claude Code statusline that turns your token usage into the
+// cooling water your AI session burns, to make an invisible cost visible.
+//
+// This file is BOTH the runtime (Claude Code runs it as the statusLine command)
+// and a small library the CLI reuses. It has zero dependencies on purpose so it
+// can be copied to ~/.claude/aqua-wasted/ and run standalone forever.
+//
+// Water model (see README for sources and the honest disclaimer):
+//   Based on Li et al. "Making AI Less Thirsty" (UC Riverside) and the
+//   Washington Post 2024 reporting. Generating tokens costs far more water than
+//   reading context, so output and input tokens are weighted separately.
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// ml of cooling water attributed per token, by scariness tier.
+const TIERS = {
+  conservative: { output: 0.01, input: 0.002 },  // modern, efficient 2025 models
+  headline: { output: 0.03, input: 0.0075 },      // maps 1:1 to the UC Riverside table
+  spicy: { output: 0.1, input: 0.025 },           // GPT 4 era, hot region, still under the studied max
+};
+
+const BOTTLE_ML = 500; // a standard water bottle, for relatable framing
+
+const DEFAULT_CONFIG = {
+  tier: 'headline',
+  unit: 'ml',          // auto | ml | dl | L
+  bottles: true,
+  emoji: '\u{1F4A7}',  // droplet
+  label: 'Aqua wasted',
+  color: 'cyan',       // cyan | blue | red | yellow | green | magenta | false
+  locale: 'en-US',
+  chain: null,         // an existing statusLine command to run first, then append ours
+};
+
+function loadConfig(dir) {
+  try {
+    const p = path.join(dir, 'config.json');
+    if (fs.existsSync(p)) {
+      return Object.assign({}, DEFAULT_CONFIG, JSON.parse(fs.readFileSync(p, 'utf8')));
+    }
+  } catch (e) {
+    // fall through to defaults
+  }
+  return Object.assign({}, DEFAULT_CONFIG);
+}
+
+// Sum every token recorded in a session transcript (the cumulative figure that
+// makes the number climb dramatically). Shape matches Claude Code JSONL lines.
+function sumTokensFromTranscript(transcriptPath) {
+  const totals = { input: 0, cacheCreation: 0, cacheRead: 0, output: 0 };
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) return totals;
+  let text = '';
+  try {
+    text = fs.readFileSync(transcriptPath, 'utf8');
+  } catch (e) {
+    return totals;
+  }
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch (e) {
+      continue;
+    }
+    const u = obj && obj.message && obj.message.usage;
+    if (!u) continue;
+    totals.input += u.input_tokens || 0;
+    totals.cacheCreation += u.cache_creation_input_tokens || 0;
+    totals.cacheRead += u.cache_read_input_tokens || 0;
+    totals.output += u.output_tokens || 0;
+  }
+  return totals;
+}
+
+// Fallback when the transcript is missing: use the live context window numbers
+// Claude Code now passes on stdin.
+function tokensFromPayload(payload) {
+  const totals = { input: 0, cacheCreation: 0, cacheRead: 0, output: 0 };
+  const cu = payload && payload.context_window && payload.context_window.current_usage;
+  if (cu) {
+    totals.input = cu.input_tokens || 0;
+    totals.cacheCreation = cu.cache_creation_input_tokens || 0;
+    totals.cacheRead = cu.cache_read_input_tokens || 0;
+    totals.output = cu.output_tokens || 0;
+  }
+  return totals;
+}
+
+function computeWaterMl(totals, tierName) {
+  const tier = TIERS[tierName] || TIERS.headline;
+  const inputSide = totals.input + totals.cacheCreation + totals.cacheRead;
+  return totals.output * tier.output + inputSide * tier.input;
+}
+
+function formatNumber(n, decimals, locale) {
+  const v = Number(n.toFixed(decimals));
+  try {
+    return v.toLocaleString(locale || 'en-US');
+  } catch (e) {
+    return String(v);
+  }
+}
+
+function formatWater(ml, unit, locale) {
+  if (unit === 'ml') return formatNumber(Math.round(ml), 0, locale) + ' ml';
+  if (unit === 'dl') return formatNumber(ml / 100, 1, locale) + ' dl';
+  if (unit === 'L') return formatNumber(ml / 1000, 2, locale) + ' L';
+  // auto
+  if (ml < 1000) return formatNumber(Math.round(ml), 0, locale) + ' ml';
+  const liters = ml / 1000;
+  return liters < 10
+    ? formatNumber(liters, 2, locale) + ' L'
+    : formatNumber(liters, 1, locale) + ' L';
+}
+
+const ANSI = { cyan: '36', blue: '34', red: '31', yellow: '33', green: '32', magenta: '35' };
+
+function colorize(text, color) {
+  if (!color || !ANSI[color]) return text;
+  return '\x1b[' + ANSI[color] + 'm' + text + '\x1b[0m';
+}
+
+function renderSegment(totals, cfg) {
+  const ml = computeWaterMl(totals, cfg.tier);
+  const bottles = Math.round(ml / BOTTLE_ML);
+  const bottleWord = bottles === 1 ? 'bottle' : 'bottles';
+  const bottleNote =
+    cfg.bottles && bottles >= 1
+      ? ' (≈ ' + formatNumber(bottles, 0, cfg.locale) + ' ' + bottleWord + ')'
+      : '';
+  const text = cfg.emoji + ' ' + cfg.label + ' ' + formatWater(ml, cfg.unit, cfg.locale) + bottleNote;
+  return colorize(text, cfg.color);
+}
+
+// Run an existing statusLine command, passing the same stdin through, so we
+// append to it rather than replacing it.
+function runChain(chainCmd, stdinRaw) {
+  if (!chainCmd) return '';
+  try {
+    const res = spawnSync(chainCmd, {
+      shell: true,
+      input: stdinRaw,
+      encoding: 'utf8',
+      timeout: 5000,
+    });
+    return (res.stdout || '').replace(/\s+$/, '');
+  } catch (e) {
+    return '';
+  }
+}
+
+function main() {
+  let stdinRaw = '';
+  try {
+    stdinRaw = fs.readFileSync(0, 'utf8');
+  } catch (e) {
+    stdinRaw = '';
+  }
+  let payload = {};
+  try {
+    payload = JSON.parse(stdinRaw) || {};
+  } catch (e) {
+    payload = {};
+  }
+
+  const cfg = loadConfig(__dirname);
+
+  let totals = sumTokensFromTranscript(payload.transcript_path);
+  const sum = totals.input + totals.cacheCreation + totals.cacheRead + totals.output;
+  if (sum === 0) totals = tokensFromPayload(payload);
+
+  const base = runChain(cfg.chain, stdinRaw);
+  const segment = renderSegment(totals, cfg);
+  process.stdout.write(base ? base + '  ' + segment : segment);
+}
+
+module.exports = {
+  TIERS,
+  BOTTLE_ML,
+  DEFAULT_CONFIG,
+  loadConfig,
+  sumTokensFromTranscript,
+  tokensFromPayload,
+  computeWaterMl,
+  formatWater,
+  formatNumber,
+  renderSegment,
+};
+
+if (require.main === module) main();