context-carwash 0.1.3 → 0.1.5

package/README.md

@@ -5,7 +5,7 @@ A small, local-first utility for Claude Code.
 - **Meter:** a quiet estimate of the active context window in the status line.
 - **Wash:** when you ask, Claude writes a short handoff brief, and your next `/clear` starts a fresh session that begins with it.
 
-Nothing happens automatically, and nothing leaves your machine. The one exception: the installer asks npm whether a newer version is out.
+Nothing happens automatically, and nothing leaves your machine. Two exceptions: the installer asks npm whether a newer version is out, and `carwash stats --share` sends anonymous totals if you run it and say yes.
 
 **Status:** pre-release. The meter and the typed `/wash` command work today. Clickable links in the status line and the one-step restart are not built yet. See [plan-3.md](plan-3.md) for the design.
 
@@ -59,6 +59,7 @@ Your old conversation is not deleted. It stays in `/resume`.
 | `/wash detailed` | Adds rationale, history, test results, risks, a step checklist |
 | `/wash discard` | Drop the brief. `/clear` is a normal clear again |
 | `/wash load [id]` | Make a waiting brief the one your next `/clear` uses |
+| `/wash stats` | How much context your washes have saved (see below) |
 | `/wash help` | Explain the meter and these options, with this session's size limits |
 
 Each level has a size limit: the most tokens its brief may take, worked out from what the conversation is using (a hundredth for `light`, three hundredths for `mid`, a tenth for `detailed`). `/wash help` shows the limits for the session you are in.
@@ -74,9 +75,40 @@ Things worth knowing:
 - **Closed the terminal before clearing?** Start `claude` in the same folder. If exactly one brief is waiting for that folder, it is under 12 hours old, and the session that wrote it has ended, it is loaded. If there is any doubt about which brief is meant, nothing is loaded and you are shown what is waiting, with the `/wash load <id>` to use.
 - **Briefs expire after 48 hours.** A delivered brief is kept for 24 hours in case you want it again (`/wash load <id>`), then deleted.
 
+## Stats
+
+```sh
+npx context-carwash stats
+```
+
+```text
+Carwash stats, since 3 Oct 2026 (12 days)
+
+  Briefs written              7  (light 1 · mid 5 · detailed 1)
+  Started fresh with one      6
+  Prompts in fresh sessions   94  (410 requests to Claude)
+  Context not re-sent         ~21M tokens
+  Spent writing briefs        ~0.9M tokens
+  Net saved                   ~20M tokens
+```
+
+`/wash stats` shows the same inside Claude Code, at no cost.
+
+How it is worked out: every request to Claude carries the whole conversation, and a single prompt can make many requests while Claude uses tools. After a wash, each request in the fresh session starts from the brief instead of the old conversation. Claude Code's transcript of that session records the size of every request, so Carwash counts the requests and multiplies by the gap. Nothing is assumed about how long you would have kept going: only requests you actually made count. Counting stops where the old session would have compacted on its own.
+
+Claude caches repeated context and charges about a tenth for it, so in money terms the saving is roughly a tenth of these numbers. The brief cost counts every brief written, used or not.
+
+### Sharing your stats
+
+```sh
+npx context-carwash stats --share
+```
+
+This shows every field it would send, and sends only if you say yes. It sends totals to a Google Form: a random share id made for sharing only (so sharing again replaces your last share), the Carwash version, your operating system, days since your first brief, and the numbers above. No names, folders, projects, prompts or briefs. You are not signed in to send it.
+
 ## Where things are kept
 
-Briefs are stored in `~/.carwash`, readable only by you, and never inside your project. Nothing is uploaded, and there is no telemetry. The installer reads the newest version number from npm, and nothing else goes online; set `CARWASH_NO_UPDATE_CHECK=1` to skip even that.
+Briefs are stored in `~/.carwash`, readable only by you, and never inside your project. So is the stats ledger (`~/.carwash/stats`): one small file per brief with its size, its level, and which fresh sessions it went to, but never the brief or your prompts. Nothing is uploaded in the background, and there is no telemetry. The installer reads the newest version number from npm (set `CARWASH_NO_UPDATE_CHECK=1` to skip that), and `stats --share` sends only when you run it and say yes.
 
 If a hook fails it stays silent and writes the error to `~/.carwash/errors.log`.
 
@@ -86,7 +118,7 @@ If a hook fails it stays silent and writes the error to `~/.carwash/errors.log`.
 npx context-carwash uninstall
 ```
 
-This puts `settings.json` back exactly as it was. If you have edited the file since installing, it removes only Carwash's own status line and hooks and keeps your edits. It then removes the `/wash` command and deletes `~/.carwash`, including any briefs still waiting.
+This puts `settings.json` back exactly as it was. If you have edited the file since installing, it removes only Carwash's own status line and hooks and keeps your edits. It then removes the `/wash` command and deletes `~/.carwash`, including any briefs still waiting and your stats.
 
 ## Limitations
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-carwash",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "A quiet context meter and deliberate fresh-session handoff for Claude Code.",
   "license": "MIT",
   "repository": {

package/src/cli.mjs

@@ -4,6 +4,8 @@ import { applyInstall, applyUninstall, describeInstall, describeUninstall, packa
 import { UserError } from './install/settings.mjs';
 import { isNewer, latestVersion, runRelease } from './install/update.mjs';
 import { errorLogPath, welcomedPath } from './paths.mjs';
+import { refreshLedger, totals } from './stats/ledger.mjs';
+import { FORM, describeShare, sendShare, shareId, sharePayload, shareReady, statsReport } from './stats/report.mjs';
 import { render } from './statusline/render.mjs';
 import { statusline } from './statusline/run.mjs';
 import { runHook } from './wash/hooks.mjs';
@@ -15,6 +17,7 @@ Usage: carwash <command>
   install [--yes]     Add the context meter and the /wash command to Claude Code
   uninstall [--yes]   Undo everything install did
   preview             Print sample meters in this terminal
+  stats [--share]     Show how much context /wash has saved; --share sends the totals anonymously, after asking
   --version           Print the version
 
 Inside Claude Code, once installed:
@@ -23,9 +26,11 @@ Inside Claude Code, once installed:
   /clear                           Start fresh with the brief that is ready
   /wash discard                    Drop the brief; /clear is a normal clear again
   /wash load [id]                  Make a waiting brief the one /clear will use
+  /wash stats                      The same totals as carwash stats
   /wash help                       Explain the meter and the options
 
-Nothing happens automatically. Only install goes online, to ask npm for the newest version.`;
+Nothing happens automatically. Only two things go online: install, to ask npm
+for the newest version, and stats --share, once you have said yes.`;
 
 async function readAll(stream) {
   if (stream.isTTY) return '';
@@ -88,7 +93,7 @@ function logError(env, error) {
   }
 }
 
-export async function main(argv, { env = process.env, stdin = process.stdin, stdout = process.stdout, stderr = process.stderr, latest = latestVersion, handOff = runRelease } = {}) {
+export async function main(argv, { env = process.env, stdin = process.stdin, stdout = process.stdout, stderr = process.stderr, latest = latestVersion, handOff = runRelease, form = FORM, share = sendShare } = {}) {
   const [command, ...rest] = argv;
   const yes = rest.includes('--yes') || rest.includes('-y');
   try {
@@ -99,7 +104,7 @@ export async function main(argv, { env = process.env, stdin = process.stdin, std
       case 'hook': {
         let output = null;
         try {
-          output = runHook({ input: await readAll(stdin), env });
+          output = runHook({ input: await readAll(stdin), env, onError: (error) => logError(env, error) });
         } catch (error) {
           logError(env, error);
         }
@@ -142,6 +147,32 @@ export async function main(argv, { env = process.env, stdin = process.stdin, std
         stdout.write('Uninstalled.\n');
         return 0;
       }
+      case 'stats': {
+        const sum = totals(refreshLedger(env, { force: true }));
+        stdout.write(statsReport(sum) + '\n');
+        if (!rest.includes('--share')) return 0;
+        stdout.write('\n');
+        if (!shareReady(form)) {
+          stdout.write('Sharing is not switched on in this version yet. Nothing was sent.\n');
+          return 1;
+        }
+        if (!sum.washes) {
+          stdout.write('There is nothing to share yet. Nothing was sent.\n');
+          return 1;
+        }
+        const payload = sharePayload(sum, { shareId: shareId(env), version: packageVersion() });
+        stdout.write(describeShare(payload) + '\n\n');
+        if (!(await confirm('Send it?', { yes, stdin, stdout }))) {
+          stdout.write('Nothing was sent.\n');
+          return 1;
+        }
+        if (!(await share(payload, { form }))) {
+          stdout.write('Could not reach the form, so nothing was sent. Try again later.\n');
+          return 1;
+        }
+        stdout.write('Sent. Thank you.\n');
+        return 0;
+      }
       case 'preview':
         preview(env, stdout);
         return 0;

package/src/paths.mjs

@@ -26,6 +26,13 @@ export const consumedDir = (env = process.env) => join(carwashHome(env), 'consum
 // Small per-session notes: the last usage reading and a wash in progress.
 export const sessionsDir = (env = process.env) => join(carwashHome(env), 'sessions');
 
+// The savings ledger behind `carwash stats`: one file per brief written.
+export const statsDir = (env = process.env) => join(carwashHome(env), 'stats');
+
+// A random id made the first time someone shares their stats, so a repeat
+// share can replace the earlier one. It is not derived from anything.
+export const shareIdPath = (env = process.env) => join(carwashHome(env), 'share-id');
+
 export const errorLogPath = (env = process.env) => join(carwashHome(env), 'errors.log');
 
 // Present once the first-run welcome has been shown.

package/src/skill/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: wash
 description: Context Carwash. Writes a short handoff brief of this session, so that /clear can start a fresh session that carries on from it.
-argument-hint: "[light | mid | detailed | discard | load <id> | help]"
+argument-hint: "[light | mid | detailed | discard | load <id> | stats | help]"
 disable-model-invocation: true
 metadata:
   installed-by: context-carwash

package/src/stats/ledger.mjs

@@ -0,0 +1,166 @@
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { readJson, writePrivateJson } from '../files.mjs';
+import { statsDir } from '../paths.mjs';
+
+// The savings ledger. Briefs themselves are deleted within days, so each one
+// written leaves a small entry here: its level, what writing it cost, and the
+// fresh sessions it was delivered to. Nothing in it leaves this machine unless
+// the user runs `carwash stats --share` and says yes, and then only totals.
+//
+// What a wash saves is measured, not assumed. Every request Claude Code sends
+// carries the whole conversation. A fresh session's transcript records the
+// size of each request, so for every request after a wash the saving is the
+// gap between the old session's size and the fresh session's starting size.
+
+const DAY = 24 * 3_600_000;
+
+// Roughly where Claude Code compacts a session on its own. Past this point the
+// old session would have shrunk anyway, so requests beyond it count for nothing.
+export const AUTO_COMPACT_SHARE = 0.9;
+
+const keyOf = (record) => `${Date.parse(record.createdAt).toString(36)}-${record.id}`;
+const fileOf = (env, key) => join(statsDir(env), `${key}.json`);
+
+// A brief was saved. `wash` is the wash that produced it.
+export function recordWash(env, record, wash) {
+  const key = keyOf(record);
+  writePrivateJson(fileOf(env, key), {
+    key,
+    level: record.level,
+    washedAt: record.createdAt,
+    used: record.used ?? null,
+    size: wash.size ?? null,
+    tokens: record.tokens,
+    attempts: (wash.rewrites ?? 0) + 1,
+    deliveries: [],
+  });
+}
+
+// A brief was handed to a fresh session.
+export function recordDelivery(env, record, payload, now = Date.now()) {
+  const file = fileOf(env, keyOf(record));
+  const entry = readJson(file);
+  if (!entry || typeof payload.transcript_path !== 'string') return;
+  entry.deliveries.push({ sessionId: payload.session_id ?? null, transcript: payload.transcript_path, at: new Date(now).toISOString(), measured: null });
+  writePrivateJson(file, entry);
+}
+
+export function readLedger(env) {
+  let names;
+  try {
+    names = readdirSync(statsDir(env));
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const name of names) {
+    if (!name.endsWith('.json')) continue;
+    const entry = readJson(join(statsDir(env), name));
+    if (entry && `${entry.key}.json` === name && Array.isArray(entry.deliveries) && Number.isFinite(Date.parse(entry.washedAt))) entries.push(entry);
+  }
+  return entries.sort((a, b) => Date.parse(a.washedAt) - Date.parse(b.washedAt));
+}
+
+// A line of the transcript the user typed, as opposed to a tool result, a
+// shell command, a slash command's output or a compaction summary.
+function isPrompt(line) {
+  if (line.type !== 'user' || line.isMeta || line.isCompactSummary) return false;
+  const content = line.message?.content;
+  if (typeof content === 'string') return !content.trimStart().startsWith('<');
+  return Array.isArray(content) && content.some((block) => block?.type === 'text') && !content.some((block) => block?.type === 'tool_result');
+}
+
+// Count what a fresh session sent after a wash. `before` is the old session's
+// size when the brief was written, `size` its context window.
+export function measure(text, before, size) {
+  const limit = size ? size * AUTO_COMPACT_SHARE : Infinity;
+  const seen = new Set();
+  let start = null;
+  let prompts = 0;
+  let requests = 0;
+  for (const raw of text.split('\n')) {
+    let line;
+    try {
+      line = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (!line || line.isSidechain) continue;
+    // Compacted: the comparison with the old session no longer holds.
+    if (line.type === 'system' && line.subtype === 'compact_boundary') break;
+    if (isPrompt(line)) {
+      prompts++;
+      continue;
+    }
+    if (line.type !== 'assistant') continue;
+    // One request can be written as several lines; they share an id.
+    const id = line.message?.id;
+    const usage = line.message?.usage;
+    if (!id || !usage || seen.has(id)) continue;
+    seen.add(id);
+    const sent = (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+    start ??= sent;
+    if (before - start <= 0 || sent + (before - start) > limit) break;
+    requests++;
+  }
+  const gap = start === null ? 0 : Math.max(0, before - start);
+  return { prompts: requests ? prompts : 0, requests, start, saved: gap * requests };
+}
+
+// Bring each delivery's measurement up to date with its transcript. Without
+// `force`, a measurement less than a day old is left alone, so a session start
+// does not reread transcripts every time. A transcript that has gone (Claude
+// Code deletes old ones) keeps its last measurement.
+export function refreshLedger(env, { now = Date.now(), force = false } = {}) {
+  const entries = readLedger(env);
+  for (const entry of entries) {
+    if (!(entry.used > 0)) continue;
+    let changed = false;
+    for (const delivery of entry.deliveries) {
+      const last = delivery.measured;
+      if (last && !force && now - last.at < DAY) continue;
+      let mtime;
+      try {
+        mtime = statSync(delivery.transcript).mtimeMs;
+      } catch {
+        continue;
+      }
+      if (last && last.mtime === mtime) continue;
+      let text;
+      try {
+        text = readFileSync(delivery.transcript, 'utf8');
+      } catch {
+        continue;
+      }
+      delivery.measured = { ...measure(text, entry.used, entry.size), mtime, at: now };
+      changed = true;
+    }
+    if (changed) writePrivateJson(fileOf(env, entry.key), entry);
+  }
+  return entries;
+}
+
+// What writing a brief cost: each attempt re-read the old session and wrote
+// the brief out.
+export const costOf = (entry) => (entry.used > 0 ? entry.attempts * (entry.used + entry.tokens) : 0);
+
+export function totals(entries, now = Date.now()) {
+  const sum = { washes: entries.length, levels: {}, delivered: 0, prompts: 0, requests: 0, notResent: 0, briefCost: 0, since: null, days: 0 };
+  for (const entry of entries) {
+    sum.levels[entry.level] = (sum.levels[entry.level] ?? 0) + 1;
+    sum.briefCost += costOf(entry);
+    if (entry.deliveries.length) sum.delivered++;
+    for (const { measured } of entry.deliveries) {
+      if (!measured) continue;
+      sum.prompts += measured.prompts;
+      sum.requests += measured.requests;
+      sum.notResent += measured.saved;
+    }
+  }
+  if (entries.length) {
+    sum.since = entries[0].washedAt;
+    sum.days = Math.max(1, Math.ceil((now - Date.parse(sum.since)) / DAY));
+  }
+  return sum;
+}

package/src/stats/report.mjs

@@ -0,0 +1,125 @@
+import { randomBytes } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { writeFileAtomic } from '../files.mjs';
+import { shareIdPath } from '../paths.mjs';
+import { formatTokens } from '../statusline/render.mjs';
+
+// `carwash stats` and `/wash stats`: the ledger's totals in words, and the
+// anonymous share that `carwash stats --share` sends after asking.
+
+const LEVEL_ORDER = ['light', 'mid', 'detailed'];
+
+const tokens = (n) => `~${formatTokens(n)} tokens`;
+
+export function statsReport(sum, { inClaude = false } = {}) {
+  if (!sum.washes) {
+    return 'Carwash stats: no briefs written yet. Once you have used /wash and /clear, this shows how much context they kept from being sent again.';
+  }
+  const since = new Date(sum.since).toLocaleDateString('en-GB', { day: 'numeric', month: 'short', year: 'numeric' });
+  const levels = LEVEL_ORDER.filter((name) => sum.levels[name]).map((name) => `${name} ${sum.levels[name]}`).join(' · ');
+  const net = sum.notResent - sum.briefCost;
+  const row = (label, value) => `  ${label.padEnd(28)}${value}`;
+  return [
+    `Carwash stats, since ${since} (${sum.days} day${sum.days === 1 ? '' : 's'})`,
+    '',
+    row('Briefs written', `${sum.washes}${levels ? `  (${levels})` : ''}`),
+    row('Started fresh with one', `${sum.delivered}`),
+    row('Prompts in fresh sessions', `${sum.prompts}  (${sum.requests} requests to Claude)`),
+    row('Context not re-sent', tokens(sum.notResent)),
+    row('Spent writing briefs', tokens(sum.briefCost)),
+    row(net >= 0 ? 'Net saved' : 'Net cost so far', tokens(Math.abs(net))),
+    '',
+    'How it is worked out: every request to Claude carries the whole conversation. After a wash, each request in the fresh session starts from the brief instead of the old conversation, and the difference is context that was not sent again. Counting stops where the old session would have compacted on its own.',
+    'Claude caches repeated context and charges about a tenth for it, so in money terms the saving is roughly a tenth of these numbers.',
+    '',
+    inClaude ? 'To share these totals anonymously, run in a terminal: npx context-carwash stats --share' : 'To share these totals anonymously: npx context-carwash stats --share',
+  ].join('\n');
+}
+
+// --- sharing ---------------------------------------------------------------
+
+// The Google Form shares go to. Each share becomes one row of the form's
+// response sheet.
+export const FORM = {
+  action: 'https://docs.google.com/forms/d/e/1FAIpQLScMU96dzQ1DC4p-K-09wRF6aTYC23Kw3VNmOZbnI55iyXQnYQ/formResponse',
+  fields: {
+    shareId: 'entry.444662411',
+    version: 'entry.237740820',
+    system: 'entry.1585190609',
+    days: 'entry.1959206368',
+    washes: 'entry.822622585',
+    prompts: 'entry.93311455',
+    notResent: 'entry.1048114223',
+    briefCost: 'entry.164624594',
+  },
+};
+
+const SYSTEMS = { darwin: 'macOS', linux: 'Linux', win32: 'Windows' };
+
+export function sharePayload(sum, { shareId, version, platform = process.platform }) {
+  return {
+    shareId,
+    version,
+    system: SYSTEMS[platform] ?? 'other',
+    days: sum.days,
+    washes: sum.washes,
+    prompts: sum.prompts,
+    notResent: sum.notResent,
+    briefCost: sum.briefCost,
+  };
+}
+
+const LABELS = {
+  shareId: 'Share id',
+  version: 'Carwash version',
+  system: 'Operating system',
+  days: 'Days since first brief',
+  washes: 'Briefs written',
+  prompts: 'Prompts in fresh sessions',
+  notResent: 'Context not re-sent',
+  briefCost: 'Spent writing briefs',
+};
+
+// Everything that would be sent, shown in full before asking.
+export function describeShare(payload) {
+  return [
+    'This is everything that would be sent, to a Google Form the Carwash author reads:',
+    '',
+    ...Object.entries(payload).map(([key, value]) => `  ${LABELS[key].padEnd(28)}${value}`),
+    '',
+    'The share id is a random number made on this machine for sharing only, so sharing again replaces your last share instead of counting twice.',
+    'No names, folders, projects, prompts, briefs or account details are included. You are not signed in to send it, and Google Forms does not show the author your IP address.',
+  ].join('\n');
+}
+
+// The random id for shares, made on first use.
+export function shareId(env) {
+  try {
+    const id = readFileSync(shareIdPath(env), 'utf8').trim();
+    if (/^[0-9a-f]{12}$/.test(id)) return id;
+  } catch {
+    // not made yet
+  }
+  const id = randomBytes(6).toString('hex');
+  writeFileAtomic(shareIdPath(env), `${id}\n`, 0o600);
+  return id;
+}
+
+export const shareReady = (form = FORM) => Boolean(form.action) && Object.values(form.fields).every(Boolean);
+
+// Send a share. Returns true once the form has accepted it.
+export async function sendShare(payload, { form = FORM, fetchImpl = fetch, timeoutMs = 10_000 } = {}) {
+  const body = new URLSearchParams();
+  for (const [key, value] of Object.entries(payload)) body.set(form.fields[key], String(value));
+  try {
+    const response = await fetchImpl(form.action, {
+      method: 'POST',
+      body,
+      headers: { 'content-type': 'application/x-www-form-urlencoded' },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}

package/src/wash/hooks.mjs

@@ -1,6 +1,8 @@
 import { existsSync, writeFileSync } from 'node:fs';
 import { DEFAULT_LEVEL, capFor, estimateTokens, isLevel } from '../levels.mjs';
 import { installRecordPath, welcomedPath } from '../paths.mjs';
+import { recordDelivery, recordWash, refreshLedger, totals } from '../stats/ledger.mjs';
+import { statsReport } from '../stats/report.mjs';
 import { budgetNote, composeContext, describe, helpMessage, loadedMessage, parseReply, pointerMessage, readyMessage, retryNote, stalenessLine, welcomeMessage } from './brief.mjs';
 import { repoState, worktreeRoot } from './git.mjs';
 import { currentProcess, isRunning, sameProcess } from './process.mjs';
@@ -10,7 +12,7 @@ import { AUTO_LOAD_MS, addRecord, claim, findRecords, purge, readyRecords, remov
 // Carwash's three Claude Code hooks:
 //
 //   UserPromptExpansion  /wash was typed. A level starts a wash and tells
-//                        Claude the size limit; discard, load and help are
+//                        Claude the size limit; discard, load, stats and help are
 //                        handled here and never reach Claude.
 //   Stop                 Claude finished replying. If that reply is the brief,
 //                        save it.
@@ -20,7 +22,7 @@ import { AUTO_LOAD_MS, addRecord, claim, findRecords, purge, readyRecords, remov
 // Each handler returns the JSON to print for Claude Code, or null to stay out
 // of the way. None of them ever clears, restarts, or runs anything.
 
-const USAGE = 'Usage: /wash [light | mid | detailed], /wash discard [id], /wash load [id], /wash help';
+const USAGE = 'Usage: /wash [light | mid | detailed], /wash discard [id], /wash load [id], /wash stats, /wash help';
 
 // How many times to ask for a shorter brief before keeping an oversized one.
 const MAX_REWRITES = 2;
@@ -33,6 +35,15 @@ const block = (reason) => ({ decision: 'block', reason: `Carwash: ${reason}` });
 // conversation, so it must not use up a brief meant for a person.
 const unattended = (env) => env.CLAUDE_CODE_SESSION_ATTENDED === '0' || /^sdk/.test(env.CLAUDE_CODE_ENTRYPOINT ?? '');
 
+// The savings ledger is bookkeeping: if it fails, the brief still has to work.
+function quietly(ctx, fn) {
+  try {
+    fn();
+  } catch (error) {
+    ctx.onError?.(error);
+  }
+}
+
 const cwdOf = (payload) => (typeof payload.cwd === 'string' && payload.cwd ? payload.cwd : process.cwd());
 
 // --- /wash ---------------------------------------------------------------
@@ -43,14 +54,16 @@ function onExpansion(payload, ctx) {
   if (isLevel(verb)) return begin(payload, verb, ctx);
   if (verb === 'discard') return block(discard(payload, ref, ctx));
   if (verb === 'load') return block(load(payload, ref, ctx));
+  if (verb === 'stats') return block(statsReport(totals(refreshLedger(ctx.env, { now: ctx.now, force: true }), ctx.now), { inClaude: true }));
   if (verb === 'help') return block(helpMessage(loadUsage(ctx.env, payload.session_id)?.used ?? null));
   return block(`/wash does not know "${verb}". ${USAGE}`);
 }
 
 function begin(payload, level, { env, now }) {
-  const used = loadUsage(env, payload.session_id)?.used ?? null;
+  const usage = loadUsage(env, payload.session_id);
+  const used = usage?.used ?? null;
   const cap = capFor(level, used);
-  startWash(env, payload.session_id, { promptId: payload.prompt_id ?? null, level, cap, used, startedAt: now, rewrites: 0 });
+  startWash(env, payload.session_id, { promptId: payload.prompt_id ?? null, level, cap, used, size: usage?.size ?? null, startedAt: now, rewrites: 0 });
   return { hookSpecificOutput: { hookEventName: 'UserPromptExpansion', additionalContext: budgetNote(level, cap, used) } };
 }
 
@@ -157,6 +170,7 @@ function onStop(payload, ctx) {
     },
     now,
   );
+  quietly(ctx, () => recordWash(env, record, wash));
   // One ready brief per terminal. An earlier wash of this same session is out
   // of date and goes; anything else this terminal held goes back to waiting.
   for (const other of readyRecords(env, now)) {
@@ -170,9 +184,11 @@ function onStop(payload, ctx) {
 
 // --- SessionStart --------------------------------------------------------
 
-function deliver(record, payload, { env, now }) {
+function deliver(record, payload, ctx) {
+  const { env, now } = ctx;
   // Another session may have taken it between the listing and now.
   if (!claim(env, record, payload.session_id, now)) return null;
+  quietly(ctx, () => recordDelivery(env, record, payload, now));
   const stale = stalenessLine(record.source, repoState(cwdOf(payload)));
   return {
     systemMessage: loadedMessage(record, now, stale),
@@ -207,6 +223,7 @@ function onSessionStart(payload, ctx) {
 function briefAtStart(payload, ctx) {
   const { env, now, me } = ctx;
   purge(env, now);
+  quietly(ctx, () => refreshLedger(env, { now }));
   const ready = readyRecords(env, now);
 
   // Relaunched by Carwash's shell function for one particular brief.
@@ -248,7 +265,7 @@ function briefAtStart(payload, ctx) {
 // --- entry point -----------------------------------------------------------
 
 // Handle one hook call. `input` is the JSON Claude Code sends on stdin.
-export function runHook({ input, env = process.env, platform = process.platform, now = Date.now(), me, running } = {}) {
+export function runHook({ input, env = process.env, platform = process.platform, now = Date.now(), me, running, onError } = {}) {
   let payload;
   try {
     payload = JSON.parse(input);
@@ -261,6 +278,7 @@ export function runHook({ input, env = process.env, platform = process.platform,
     now,
     me: me ?? currentProcess(env, platform),
     isRunning: running ?? ((owner) => isRunning(owner, platform)),
+    onError,
   };
   switch (payload.hook_event_name) {
     case 'UserPromptExpansion':