context-carwash 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.2.2
+
+- `carwash stats` leads with a likelier saving and shows the old figure as the most it could be. It counts only the first part of the prompts after each wash, since you would have cleared the old conversation at some point anyway. That share starts at two-thirds and is learned from how far your own Claude Code conversations go, read on your machine. Output the fresh conversation had to read again, which the old one already had, is taken off.
+- `stats --share` sends the likely figure as well as the full one.
+
 ## 0.2.1
 
 - Codex support. `install` sets up Codex too when it finds it: three hooks in `~/.codex/hooks.json` and a `$wash` command in `~/.codex/skills/wash`. Codex asks you to trust the hooks once. After `/clear`, the brief loads with your next message. Codex's status line can only show its own items, so the meter is a line after each reply instead, in colour from Codex 0.162.0 on. It is shown to you only and costs no tokens.

package/README.md

@@ -87,12 +87,16 @@ 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
+  Context not re-sent         ~11M tokens  (at most ~21M tokens)
   Spent writing briefs        ~0.9M tokens
-  Net saved                   ~20M tokens
+  Net saved                   ~10M tokens  (at most ~20M tokens)
 ```
 
-Every request to Claude or Codex sends the whole conversation again. After a wash, each request starts from the small brief instead, so Carwash counts the requests you actually made and adds up the difference. Repeated context is charged at about a tenth of the price, so in dollars you're saving roughly a tenth of these numbers. You can also see this inside Claude Code with `/wash stats`.
+Every request to Claude or Codex sends the whole conversation again. After a wash, each request starts from the small brief instead, so Carwash counts the requests you actually made and adds up the difference. Counting stops where the old conversation would have filled up and compacted on its own.
+
+You wouldn't have kept going in the old conversation forever, so the main number only counts the first part of the prompts after each wash. That's two-thirds to begin with. Carwash then adjusts it by looking at how far your own past conversations went once they were that big, so if you usually clear around 300k, a wash at 300k counts for less. Anything the fresh conversation had to read again, like a file the old one already had open, is taken off too. "At most" counts every prompt. All of this is worked out on your computer from Claude Code's own history files, and only a few numbers per conversation are kept.
+
+Repeated context is charged at about a tenth of the price, so in dollars you're saving roughly a tenth of these numbers. You can also see this inside Claude Code with `/wash stats`.
 
 If you run `stats --share`, it shows you exactly what it would send before asking.
 

package/package.json

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

package/src/cli.mjs

@@ -7,8 +7,7 @@ import { UserError } from './install/settings.mjs';
 import { isNewer, latestVersion, runRelease } from './install/update.mjs';
 import { errorLogPath, installRecordPath, welcomedPath } from './paths.mjs';
 import { readJson } from './files.mjs';
-import { refreshLedger, totals } from './stats/ledger.mjs';
-import { FORM, describeShare, sendShare, shareId, sharePayload, shareReady, statsReport } from './stats/report.mjs';
+import { FORM, describeShare, sendShare, shareId, sharePayload, shareReady, statsReport, currentTotals } from './stats/report.mjs';
 import { render } from './statusline/render.mjs';
 import { statusline } from './statusline/run.mjs';
 import { runHook } from './wash/hooks.mjs';
@@ -169,7 +168,7 @@ export async function main(argv, { env = process.env, stdin = process.stdin, std
         return 0;
       }
       case 'stats': {
-        const sum = totals(refreshLedger(env, { force: true }));
+        const sum = currentTotals(env);
         stdout.write(statsReport(sum) + '\n');
         if (!rest.includes('--share')) return 0;
         stdout.write('\n');

package/src/paths.mjs

@@ -60,3 +60,7 @@ export const legacyCommandPath = (env = process.env) => join(claudeConfigDir(env
 export const codexHooksPath = (env = process.env) => join(codexHome(env), 'hooks.json');
 export const codexSkillDir = (env = process.env) => join(codexHome(env), 'skills', 'wash');
 export const codexConfigPath = (env = process.env) => join(codexHome(env), 'config.toml');
+
+// What Carwash has learned about how far sessions usually go: a few numbers
+// per transcript, so the transcripts need not be read again.
+export const habitsPath = (env = process.env) => join(carwashHome(env), 'habits.json');

package/src/stats/habits.mjs

@@ -0,0 +1,107 @@
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { readJson, writePrivateJson } from '../files.mjs';
+import { claudeConfigDir, habitsPath } from '../paths.mjs';
+import { DEFAULT_SHARE, isPrompt, sentOf } from './ledger.mjs';
+
+// How far this person usually takes a session, learned from their own Claude
+// Code transcripts. A wash saves context only for the prompts that would
+// otherwise have been sent in the old session, and that depends on habit:
+// someone who often clears at 300k would not have gone on for long past it.
+// Everything here stays on this machine; the cache holds only sizes.
+
+const PRIOR_WEIGHT = 10; // the starting guess counts as this many sessions
+const SETTLE_MS = 3_600_000; // touched this recently, a session may still be going
+const FIRST_READ_MS = 90 * 24 * 3_600_000; // older transcripts are not read for the first time
+
+const WASH = /<command-name>\/wash<\/command-name>(?:\\n)?<command-args>(?:light|mid|detailed)?<\/command-args>/;
+
+// A session's shape: its size when each prompt was answered, whether it
+// compacted (so went on to the limit), and whether it ended in a wash.
+export function sessionShape(text) {
+  const sizes = [];
+  let waiting = false;
+  let compacted = false;
+  for (const raw of text.split('\n')) {
+    if (!raw.includes('"user"') && !raw.includes('"usage"') && !raw.includes('compact_boundary')) continue;
+    let line;
+    try {
+      line = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (!line || line.isSidechain) continue;
+    if (line.type === 'system' && line.subtype === 'compact_boundary') {
+      compacted = true;
+      break;
+    }
+    if (isPrompt(line)) waiting = true;
+    else if (waiting && line.type === 'assistant' && line.message?.usage) {
+      sizes.push(sentOf(line.message.usage));
+      waiting = false;
+    }
+  }
+  return { sizes, compacted, washed: WASH.test(text) };
+}
+
+// Bring the cache up to date with Claude Code's transcripts and return every
+// session's shape. Transcripts Claude Code has since deleted stay in the cache.
+export function learnHabits(env, { now = Date.now() } = {}) {
+  const file = habitsPath(env);
+  const sessions = readJson(file)?.sessions ?? {};
+  const root = join(claudeConfigDir(env), 'projects');
+  let changed = false;
+  let dirs = [];
+  try {
+    dirs = readdirSync(root);
+  } catch {
+    // no transcripts
+  }
+  for (const dir of dirs) {
+    let names;
+    try {
+      names = readdirSync(join(root, dir));
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      if (!name.endsWith('.jsonl')) continue;
+      const path = join(root, dir, name);
+      try {
+        const { mtimeMs } = statSync(path);
+        if (now - mtimeMs < SETTLE_MS || sessions[path]?.mtime === mtimeMs) continue;
+        if (!sessions[path] && now - mtimeMs > FIRST_READ_MS) continue;
+        sessions[path] = { mtime: mtimeMs, ...sessionShape(readFileSync(path, 'utf8')) };
+        changed = true;
+      } catch {
+        continue;
+      }
+    }
+  }
+  if (changed) {
+    try {
+      writePrivateJson(file, { version: 1, sessions });
+    } catch {
+      // learned again next time
+    }
+  }
+  return Object.values(sessions).filter((s) => !s.washed && Array.isArray(s.sizes) && s.sizes.length);
+}
+
+// The share of `turns` prompts, sent after washing a session of `before`
+// tokens, that would likely have been sent in that session anyway. Each past
+// session that reached the same size says how many more prompts it went on
+// for; one that compacted went on to the limit. The starting guess holds until
+// enough sessions have reached that size to outweigh it.
+export function shareFor(sessions, before, turns) {
+  if (!(turns > 0) || !(before > 0)) return DEFAULT_SHARE;
+  let seen = 0;
+  let kept = 0;
+  for (const { sizes, compacted } of sessions) {
+    const at = sizes.findIndex((size) => size >= before);
+    if (at < 0) continue;
+    seen++;
+    kept += compacted ? 1 : Math.min(turns, sizes.length - 1 - at) / turns;
+  }
+  return (DEFAULT_SHARE * PRIOR_WEIGHT + kept) / (PRIOR_WEIGHT + seen);
+}

package/src/stats/ledger.mjs

@@ -1,7 +1,8 @@
 import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { readJson, writePrivateJson } from '../files.mjs';
-import { statsDir } from '../paths.mjs';
+import { estimateTokens } from '../levels.mjs';
+import { consumedDir, statsDir } from '../paths.mjs';
 import { toolOf } from '../tools.mjs';
 import { tokenReading } from '../wash/rollout.mjs';
 
@@ -19,10 +20,18 @@ import { tokenReading } from '../wash/rollout.mjs';
 
 const DAY = 24 * 3_600_000;
 
+// Bumped when measuring changes, so kept measurements are redone.
+const METHOD = 2;
+
 // 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;
 
+// The starting guess at how much of the work after a wash would have been
+// done in the old session before it was cleared anyway. habits.mjs adjusts it
+// from the person's own sessions.
+export const DEFAULT_SHARE = 2 / 3;
+
 const keyOf = (record) => `${Date.parse(record.createdAt).toString(36)}-${record.id}`;
 const fileOf = (env, key) => join(statsDir(env), `${key}.json`);
 
@@ -37,6 +46,7 @@ export function recordWash(env, record, wash) {
     used: record.used ?? null,
     size: wash.size ?? null,
     tokens: record.tokens,
+    source: record.source?.transcriptPath ?? null,
     attempts: (wash.rewrites ?? 0) + 1,
     deliveries: [],
   });
@@ -71,21 +81,81 @@ export function readLedger(env) {
 
 // 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) {
+export 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');
 }
 
+// The size of one request: everything the model was sent.
+export const sentOf = (usage) => (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+
+const blocksOf = (line) => (Array.isArray(line.message?.content) ? line.message.content : []);
+
+const resultText = (block) =>
+  typeof block.content === 'string' ? block.content : Array.isArray(block.content) ? block.content.map((part) => (part?.type === 'text' ? part.text : '')).join('') : '';
+
+// Lines shorter than this are too common to say a file was read again.
+const MIN_LINE = 24;
+
+// A line as a tool shows it, without the line number a file read adds.
+const normal = (line) => line.replace(/^\s*\d+(?:\t|→)/, '').trim();
+
+function* lines(text) {
+  for (const line of text.split('\n')) {
+    const clean = normal(line);
+    if (clean.length >= MIN_LINE) yield clean;
+  }
+}
+
+// Every line a session still held from tools and from the files it wrote:
+// whatever came before its last compaction was summarised away. Compared by
+// content, so a file read with cat counts the same as one read with Read.
+export function heldLines(text) {
+  const held = new Set();
+  for (const raw of text.split('\n')) {
+    if (!raw.includes('tool_') && !raw.includes('compact_boundary')) continue;
+    let line;
+    try {
+      line = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (!line || line.isSidechain) continue;
+    if (line.type === 'system' && line.subtype === 'compact_boundary') held.clear();
+    for (const block of blocksOf(line)) {
+      const texts = block?.type === 'tool_result' ? [resultText(block)] : block?.type === 'tool_use' ? [block.input?.content, block.input?.new_string] : [];
+      for (const text of texts) if (typeof text === 'string') for (const clean of lines(text)) held.add(clean);
+    }
+  }
+  return held;
+}
+
+// The tokens of a tool result the old session already held.
+function repeated(text, held) {
+  let chars = 0;
+  for (const clean of lines(text)) if (held.has(clean)) chars += clean.length + 1;
+  return chars ? estimateTokens('x'.repeat(chars)) : 0;
+}
+
 // 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) {
+// size when the brief was written, `size` its context window, `held` the
+// lines of tool output the old session already had.
+//
+// `turns` breaks the count down by prompt, as [requests, reread]: how many
+// requests each prompt made, and how many of the tokens they sent were tool
+// output the old session already had, such as files read again. The old session already held those, so
+// they are not a saving. `likelyOf` uses this to count only the prompts that
+// would have been sent in the old session anyway.
+export function measure(text, before, size, { held = null } = {}) {
   const limit = size ? size * AUTO_COMPACT_SHARE : Infinity;
   const seen = new Set();
+  const turns = [];
   let start = null;
   let prompts = 0;
   let requests = 0;
+  let reread = 0;
   for (const raw of text.split('\n')) {
     let line;
     try {
@@ -98,6 +168,11 @@ export function measure(text, before, size) {
     if (line.type === 'system' && line.subtype === 'compact_boundary') break;
     if (isPrompt(line)) {
       prompts++;
+      turns.push([0, 0]);
+      continue;
+    }
+    if (line.type === 'user') {
+      if (held) for (const block of blocksOf(line)) if (block?.type === 'tool_result') reread += repeated(resultText(block), held);
       continue;
     }
     if (line.type !== 'assistant') continue;
@@ -106,13 +181,16 @@ export function measure(text, before, size) {
     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);
+    const sent = sentOf(usage);
     start ??= sent;
     if (before - start <= 0 || sent + (before - start) > limit) break;
     requests++;
+    if (!turns.length) turns.push([0, 0]);
+    turns.at(-1)[0]++;
+    turns.at(-1)[1] += reread;
   }
   const gap = start === null ? 0 : Math.max(0, before - start);
-  return { prompts: requests ? prompts : 0, requests, start, saved: gap * requests };
+  return { prompts: requests ? prompts : 0, requests, start, saved: gap * requests, turns: turns.filter(([n]) => n > 0) };
 }
 
 // The same count from a Codex session file. A person's prompt is a UserMessage
@@ -122,7 +200,10 @@ export function measure(text, before, size) {
 export function measureCodex(text, before, size) {
   const limit = size ? size * AUTO_COMPACT_SHARE : Infinity;
   const records = text.includes('"token_usage_record"');
+  // Newer Codex marks a prompt both ways; count turns by whichever it uses.
+  const byItem = text.includes('"UserMessage"');
   const seen = new Set();
+  const turns = [];
   let thread = null;
   let start = null;
   let items = 0;
@@ -142,10 +223,12 @@ export function measureCodex(text, before, size) {
     if (line.type === 'compacted' || (line.type === 'event_msg' && payload.type === 'context_compacted')) break;
     if (line.type === 'event_msg' && payload.type === 'item_completed' && payload.item?.type === 'UserMessage') {
       items++;
+      if (byItem) turns.push([0, 0]);
       continue;
     }
     if (line.type === 'event_msg' && payload.type === 'user_message') {
       events++;
+      if (!byItem) turns.push([0, 0]);
       continue;
     }
     let sent = null;
@@ -162,9 +245,11 @@ export function measureCodex(text, before, size) {
     start ??= sent;
     if (before - start <= 0 || sent + (before - start) > limit) break;
     requests++;
+    if (!turns.length) turns.push([0, 0]);
+    turns.at(-1)[0]++;
   }
   const gap = start === null ? 0 : Math.max(0, before - start);
-  return { prompts: requests ? Math.max(items, events) : 0, requests, start, saved: gap * requests };
+  return { prompts: requests ? Math.max(items, events) : 0, requests, start, saved: gap * requests, turns: turns.filter(([n]) => n > 0) };
 }
 
 // Bring each delivery's measurement up to date with its transcript. Without
@@ -176,6 +261,11 @@ export function refreshLedger(env, { now = Date.now(), force = false } = {}) {
   for (const entry of entries) {
     if (!(entry.used > 0)) continue;
     let changed = false;
+    if (entry.source === undefined) {
+      entry.source = sourceOf(env, entry);
+      changed = entry.source !== null;
+    }
+    let held;
     for (const delivery of entry.deliveries) {
       const last = delivery.measured;
       if (last && !force && now - last.at < DAY) continue;
@@ -185,15 +275,20 @@ export function refreshLedger(env, { now = Date.now(), force = false } = {}) {
       } catch {
         continue;
       }
-      if (last && last.mtime === mtime) continue;
+      // Measured the old way: measure again while the transcript is here.
+      if (last && last.mtime === mtime && last.method === METHOD) continue;
       let text;
       try {
         text = readFileSync(delivery.transcript, 'utf8');
       } catch {
         continue;
       }
-      const count = toolOf(delivery) === 'codex' ? measureCodex : measure;
-      delivery.measured = { ...count(text, entry.used, entry.size), mtime, at: now };
+      if (toolOf(delivery) === 'codex') {
+        delivery.measured = { ...measureCodex(text, entry.used, entry.size), method: METHOD, mtime, at: now };
+      } else {
+        if (held === undefined) held = toolOf(entry) === 'claude' ? oldLines(entry.source) : null;
+        delivery.measured = { ...measure(text, entry.used, entry.size, { held }), method: METHOD, mtime, at: now };
+      }
       changed = true;
     }
     if (changed) writePrivateJson(fileOf(env, entry.key), entry);
@@ -201,12 +296,49 @@ export function refreshLedger(env, { now = Date.now(), force = false } = {}) {
   return entries;
 }
 
+// Where the washed session's transcript is, for entries written before the
+// ledger kept it: the delivered brief remembers, until it is purged.
+function sourceOf(env, entry) {
+  const record = readJson(join(consumedDir(env), `${entry.key.slice(entry.key.indexOf('-') + 1)}.json`));
+  return typeof record?.source?.transcriptPath === 'string' ? record.source.transcriptPath : null;
+}
+
+function oldLines(path) {
+  if (typeof path !== 'string') return null;
+  try {
+    return heldLines(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// The saving if only the first `share` of the fresh session's prompts would
+// have been sent in the old session before it was cleared anyway. The
+// measured total counts every prompt; this is the likelier figure. Files read
+// again are taken off. Entries measured before turns were kept fall back to
+// the same share of the total.
+export function likelyOf(measured, share) {
+  if (!measured) return 0;
+  if (!Array.isArray(measured.turns)) return Math.round(measured.saved * share);
+  const gap = measured.requests ? measured.saved / measured.requests : 0;
+  const keep = measured.turns.length * share;
+  let total = 0;
+  measured.turns.forEach(([requests, reread], i) => {
+    total += Math.min(1, Math.max(0, keep - i)) * Math.max(0, gap * requests - reread);
+  });
+  return Math.round(total);
+}
+
 // 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: {}, tools: [], delivered: 0, prompts: 0, requests: 0, notResent: 0, briefCost: 0, since: null, days: 0 };
+// `shareOf` says, for a delivery, what share of its prompts would likely have
+// been sent in the old session anyway.
+export function totals(entries, now = Date.now(), { shareOf = () => DEFAULT_SHARE } = {}) {
+  const sum = { washes: entries.length, levels: {}, tools: [], delivered: 0, prompts: 0, requests: 0, notResent: 0, likely: 0, share: DEFAULT_SHARE, briefCost: 0, since: null, days: 0 };
+  let weighed = 0;
+  let turns = 0;
   for (const entry of entries) {
     sum.levels[entry.level] = (sum.levels[entry.level] ?? 0) + 1;
     for (const tool of [toolOf(entry), ...entry.deliveries.map(toolOf)]) if (!sum.tools.includes(tool)) sum.tools.push(tool);
@@ -217,8 +349,14 @@ export function totals(entries, now = Date.now()) {
       sum.prompts += measured.prompts;
       sum.requests += measured.requests;
       sum.notResent += measured.saved;
+      const share = shareOf(entry, measured);
+      sum.likely += likelyOf(measured, share);
+      const count = measured.turns?.length ?? measured.prompts;
+      weighed += share * count;
+      turns += count;
     }
   }
+  if (turns) sum.share = weighed / turns;
   if (entries.length) {
     sum.since = entries[0].washedAt;
     sum.days = Math.max(1, Math.ceil((now - Date.parse(sum.since)) / DAY));

package/src/stats/report.mjs

@@ -2,6 +2,8 @@ import { randomBytes } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { writeFileAtomic } from '../files.mjs';
 import { shareIdPath } from '../paths.mjs';
+import { learnHabits, shareFor } from './habits.mjs';
+import { refreshLedger, totals } from './ledger.mjs';
 import { formatTokens } from '../statusline/render.mjs';
 import { toolInfo } from '../tools.mjs';
 
@@ -12,6 +14,16 @@ const LEVEL_ORDER = ['light', 'mid', 'detailed'];
 
 const tokens = (n) => `~${formatTokens(n)} tokens`;
 
+// The ledger measured afresh, with the likely saving judged by this person's
+// own habits.
+export function currentTotals(env, now = Date.now()) {
+  const sessions = learnHabits(env, { now });
+  const sum = totals(refreshLedger(env, { now, force: true }), now, { shareOf: (entry, measured) => shareFor(sessions, entry.used, measured.turns?.length ?? measured.prompts) });
+  return { ...sum, learnedFrom: sessions.length };
+}
+
+const percent = (share) => `${Math.round(share * 100)}%`;
+
 // Who the requests went to: Claude, Codex, or both.
 const modelName = (tools = ['claude']) => (tools.length === 1 ? toolInfo(tools[0]).model : 'the model');
 
@@ -21,7 +33,9 @@ export function statsReport(sum, { inClaude = false } = {}) {
   }
   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 likely = sum.likely ?? sum.notResent;
+  const net = likely - sum.briefCost;
+  const most = sum.notResent - sum.briefCost;
   const row = (label, value) => `  ${label.padEnd(28)}${value}`;
   const model = modelName(sum.tools);
   return [
@@ -30,11 +44,12 @@ export function statsReport(sum, { inClaude = false } = {}) {
     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 ${model})`),
-    row('Context not re-sent', tokens(sum.notResent)),
+    row('Context not re-sent', `${tokens(likely)}  (at most ${tokens(sum.notResent)})`),
     row('Spent writing briefs', tokens(sum.briefCost)),
-    row(net >= 0 ? 'Net saved' : 'Net cost so far', tokens(Math.abs(net))),
+    row(net >= 0 ? 'Net saved' : 'Net cost so far', `${tokens(Math.abs(net))}  (at most ${most >= 0 ? tokens(most) : 'nothing'})`),
     '',
     `How it is worked out: every request to ${model} 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.`,
+    `You would not have gone on forever in the old session, so the main figure counts only the first ${percent(sum.share ?? 2 / 3)} of the prompts after each wash. That share starts at two-thirds and is learned from how far your own sessions go (${sum.learnedFrom ?? 0} so far). Files the fresh session had to read again are taken off. "At most" counts every prompt.`,
     model === 'Claude'
       ? 'Claude caches repeated context and charges about a tenth for it, so in money terms the saving is roughly a tenth of these numbers.'
       : 'Repeated context is cached and charged at about a tenth, so in money terms the saving is roughly a tenth of these numbers.',
@@ -57,6 +72,7 @@ export const FORM = {
     washes: 'entry.822622585',
     prompts: 'entry.93311455',
     notResent: 'entry.1048114223',
+    likely: 'entry.1068811941',
     briefCost: 'entry.164624594',
   },
 };
@@ -72,6 +88,7 @@ export function sharePayload(sum, { shareId, version, platform = process.platfor
     washes: sum.washes,
     prompts: sum.prompts,
     notResent: sum.notResent,
+    likely: sum.likely ?? sum.notResent,
     briefCost: sum.briefCost,
   };
 }
@@ -83,7 +100,8 @@ const LABELS = {
   days: 'Days since first brief',
   washes: 'Briefs written',
   prompts: 'Prompts in fresh sessions',
-  notResent: 'Context not re-sent',
+  notResent: 'Context not re-sent, at most',
+  likely: 'Context not re-sent, likely',
   briefCost: 'Spent writing briefs',
 };
 

package/src/wash/hooks.mjs

@@ -4,9 +4,9 @@ import { startNotice, versionLine } from '../install/notice.mjs';
 import { isNewer } from '../install/update.mjs';
 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 { recordDelivery, recordWash, refreshLedger } from '../stats/ledger.mjs';
 import { colorDepth } from '../statusline/color.mjs';
-import { statsReport } from '../stats/report.mjs';
+import { currentTotals, statsReport } from '../stats/report.mjs';
 import { budgetNote, composeContext, describe, helpMessage, loadedMessage, parseReply, pointerMessage, readyMessage, replyMeterMessage, retryNote, stalenessLine, welcomeMessage } from './brief.mjs';
 import { isTool, toolInfo, toolOf } from '../tools.mjs';
 import { repoState, worktreeRoot } from './git.mjs';
@@ -93,7 +93,7 @@ function washCommand(payload, args, event, ctx) {
   if (isLevel(verb)) return begin(payload, verb, event, 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 === 'stats') return block(statsReport(currentTotals(ctx.env, ctx.now), { inClaude: true }));
   if (verb === 'help') return block(helpMessage(ctx.usage(payload)?.used ?? null, versionLine(ctx.version, ctx.env), ctx.tool));
   return block(`${toolInfo(ctx.tool).wash} does not know "${verb}". ${usageLine(ctx.tool)}`);
 }