context-carwash 0.2.0 → 0.2.2

package/src/stats/ledger.mjs

@@ -1,24 +1,37 @@
 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';
 
 // 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.
+// What a wash saves is measured, not assumed. Every request Claude Code or
+// Codex 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. Each tool writes its transcript its own way, so each has its
+// own reader below; the arithmetic is the same.
 
 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`);
 
@@ -27,22 +40,26 @@ export function recordWash(env, record, wash) {
   const key = keyOf(record);
   writePrivateJson(fileOf(env, key), {
     key,
+    ...(toolOf(record) === 'claude' ? {} : { tool: toolOf(record) }),
     level: record.level,
     washedAt: record.createdAt,
     used: record.used ?? null,
     size: wash.size ?? null,
     tokens: record.tokens,
+    source: record.source?.transcriptPath ?? null,
     attempts: (wash.rewrites ?? 0) + 1,
     deliveries: [],
   });
 }
 
-// A brief was handed to a fresh session.
-export function recordDelivery(env, record, payload, now = Date.now()) {
+// A brief was handed to a fresh session, in `tool`. A brief asked for by id
+// can be delivered in the other tool, so each delivery says whose transcript
+// it is.
+export function recordDelivery(env, record, payload, now = Date.now(), tool = 'claude') {
   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 });
+  entry.deliveries.push({ sessionId: payload.session_id ?? null, ...(tool === 'claude' ? {} : { tool }), transcript: payload.transcript_path, at: new Date(now).toISOString(), measured: null });
   writePrivateJson(file, entry);
 }
 
@@ -64,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 {
@@ -91,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;
@@ -99,13 +181,75 @@ 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
+// item (or, from older Codex, a user_message event), and each request leaves a
+// token_usage_record (or, from older Codex, a token_count event). Requests made
+// by subagents are left out, as Claude Code's sidechains are above.
+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;
+  let events = 0;
+  let requests = 0;
+  for (const raw of text.split('\n')) {
+    let line;
+    try {
+      line = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (!line || typeof line !== 'object') continue;
+    const payload = line.payload && typeof line.payload === 'object' ? line.payload : {};
+    if (line.type === 'session_meta') thread ??= payload.id ?? payload.session_id ?? null;
+    // Compacted: the comparison with the old session no longer holds.
+    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;
+    if (records && line.type === 'token_usage_record') {
+      if (thread && payload.thread_id && payload.thread_id !== thread) continue;
+      const id = payload.response_id;
+      if (id && seen.has(id)) continue;
+      if (id) seen.add(id);
+      sent = payload.usage?.input_tokens;
+    } else if (!records) {
+      sent = tokenReading(line)?.used;
+    }
+    if (!Number.isFinite(sent) || sent <= 0) continue;
+    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, turns: turns.filter(([n]) => n > 0) };
 }
 
 // Bring each delivery's measurement up to date with its transcript. Without
@@ -117,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;
@@ -126,14 +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;
       }
-      delivery.measured = { ...measure(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);
@@ -141,14 +296,52 @@ 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: {}, 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);
     sum.briefCost += costOf(entry);
     if (entry.deliveries.length) sum.delivered++;
     for (const { measured } of entry.deliveries) {
@@ -156,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,7 +2,10 @@ 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';
 
 // `carwash stats` and `/wash stats`: the ledger's totals in words, and the
 // anonymous share that `carwash stats --share` sends after asking.
@@ -11,26 +14,45 @@ 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');
+
 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 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 [
     `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('Prompts in fresh sessions', `${sum.prompts}  (${sum.requests} requests to ${model})`),
+    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 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.',
+    `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.',
     '',
     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');
@@ -50,6 +72,7 @@ export const FORM = {
     washes: 'entry.822622585',
     prompts: 'entry.93311455',
     notResent: 'entry.1048114223',
+    likely: 'entry.1068811941',
     briefCost: 'entry.164624594',
   },
 };
@@ -65,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,
   };
 }
@@ -76,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/tools.mjs

@@ -0,0 +1,40 @@
+// The coding tools Carwash works with, and the few things that differ between
+// them in what people see: the tool's name, how the command is typed, and how
+// a brief is picked up after /clear.
+//
+//   Claude Code  /wash is a skill. A brief loads the moment /clear runs, and
+//                the status line shows the meter.
+//   Codex        $wash is a skill, mentioned with a dollar sign (Codex keeps
+//                the slash for its own commands). Codex starts the new session
+//                when the first message after /clear is sent, so that is when
+//                the brief loads. Its status line only shows its own items,
+//                so the meter is a line after each reply instead.
+
+export const TOOLS = {
+  claude: {
+    id: 'claude',
+    name: 'Claude Code',
+    model: 'Claude',
+    wash: '/wash',
+    meter: true,
+    replyMeter: false,
+    afterClear: 'Type /clear to start fresh with it.',
+  },
+  codex: {
+    id: 'codex',
+    name: 'Codex',
+    model: 'Codex',
+    wash: '$wash',
+    meter: false,
+    replyMeter: true,
+    afterClear: 'Type /clear, then send your next message (even just "continue"): the brief loads with it.',
+  },
+};
+
+export const isTool = (id) => Object.hasOwn(TOOLS, id);
+
+// The tool behind a brief or a ledger entry. Everything written before Codex
+// support came from Claude Code and carries no tool.
+export const toolOf = (thing) => (thing && isTool(thing.tool) ? thing.tool : 'claude');
+
+export const toolInfo = (id) => TOOLS[isTool(id) ? id : 'claude'];

package/src/wash/brief.mjs

@@ -1,9 +1,13 @@
 import { CHARS_PER_TOKEN, capFor } from '../levels.mjs';
+import { colorAt, paint } from '../statusline/color.mjs';
 import { formatTokens } from '../statusline/render.mjs';
+import { toolInfo, toolOf } from '../tools.mjs';
 
 // The wording around a brief: what Claude is told when writing one, how its
 // reply is recognised, and what the user and the next session are shown. Also
 // the two places Carwash explains itself: the first-run welcome and /wash help.
+// Wording that names the tool or its commands takes the tool's id (see
+// tools.mjs); Claude Code is the default.
 
 // Every brief opens with this heading. It is how a reply is known to be a
 // brief, and where anything written before it is cut off.
@@ -70,14 +74,14 @@ export function retryNote(level, cap, tokens) {
   );
 }
 
-const NEXT_STEP = 'Type /clear to start fresh with it. This is not a normal clear: your brief carries over. Old session stays in /resume.';
+const nextStep = (tool) => `${toolInfo(tool).afterClear} This is not a normal clear: your brief carries over. Old session stays in /resume.`;
 
 // Shown to the user once a brief has been saved.
-export function readyMessage(record) {
+export function readyMessage(record, tool = toolOf(record)) {
   let size = sizeOf(record);
   if (record.overCap) size += `, which is over the ${formatTokens(record.cap)} cap even after asking for a shorter one`;
   else if (record.cap) size += ` of ${formatTokens(record.cap)} cap`;
-  return `Brief ready ✓ ${size}. ${NEXT_STEP}`;
+  return `Brief ready ✓ ${size}. ${nextStep(tool)}`;
 }
 
 // One line on how the repository differs from when the brief was written, or
@@ -100,16 +104,46 @@ export function stalenessLine(source, current) {
 
 // Shown to the user when a fresh session starts with a brief. The old
 // session's size is the reading /wash was sized from, when there was one.
-export function loadedMessage(record, now, stale) {
+export function loadedMessage(record, now, stale, tool = 'claude') {
   const before = Number.isFinite(record.used) && record.used > 0 ? `, down from ~${formatTokens(record.used)} in the old session` : '';
-  return (
-    `Loaded your Carwash brief (${sizeOf(record)}, ${ageOf(record, now)})${before}.${stale ? ` ${stale}` : ''} ` +
-    "That size is the brief alone; the meter also counts Claude Code's own baseline."
-  );
+  const loaded = `Loaded your Carwash brief (${sizeOf(record)}, ${ageOf(record, now)})${before}.${stale ? ` ${stale}` : ''}`;
+  if (!toolInfo(tool).meter && !toolInfo(tool).replyMeter) return loaded;
+  return `${loaded} That size is the brief alone; the meter also counts ${toolInfo(tool).name}'s own baseline.`;
+}
+
+const METER_CELLS = 15;
+// From this share of the window on, the meter says so in words.
+const FULL_AT = 75;
+
+// The meter as one line, for a tool that shows it after each reply rather than
+// in its status line: the tokens in use, a bar for how full the window is, and
+// what to do about it. `size` may be unknown, and then there is no bar. The
+// bar's cells and "getting full" take the status line's colours at `depth`
+// ('none' for plain text).
+export function replyMeterMessage({ used, size }, tool = 'codex', depth = 'none') {
+  const parts = [`session context ~${formatTokens(used)}`];
+  const pct = size ? Math.min(100, (used / size) * 100) : null;
+  if (pct !== null) {
+    const filled = Math.round((pct / 100) * METER_CELLS);
+    let cells = '';
+    for (let i = 0; i < filled; i++) cells += paint('█', colorAt(((i + 0.5) / METER_CELLS) * 100), depth);
+    parts.push(`[${cells}${'░'.repeat(METER_CELLS - filled)}]`);
+  }
+  const hint = `${toolInfo(tool).wash} to compress, then /clear`;
+  parts.push(pct !== null && pct >= FULL_AT ? `${paint('getting full', colorAt(pct), depth)} · ${hint}` : hint);
+  return parts.join('  ');
 }
 
 // Shown once, at the first session after install.
-export function welcomeMessage() {
+export function welcomeMessage(tool = 'claude') {
+  if (tool === 'codex') {
+    return [
+      'Context Carwash installed ✓ (shown once)',
+      '  • After each reply: tokens in use, and how full the context is',
+      '  • Getting full? $wash, then /clear and send your next message. You start fresh, right where you left off',
+      '  • Nothing runs on its own · $wash help for options',
+    ].join('\n');
+  }
   return [
     'Context Carwash installed ✓ (shown once)',
     '  • Status line: tokens in use, and how full the context is',
@@ -127,14 +161,18 @@ const LEVEL_NOTES = {
 
 // /wash help. `used` is this session's reading, when known, so each level can
 // show the most tokens its brief may take here.
-export function helpMessage(used, footer = null) {
-  const row = (args, note) => `  /wash ${args.padEnd(16)}${note}`;
+export function helpMessage(used, footer = null, tool = 'claude') {
+  const { wash, model, meter, replyMeter } = toolInfo(tool);
+  const row = (args, note) => `  ${wash} ${args.padEnd(16)}${note}`;
   const level = (name) => {
     const cap = capFor(name, used);
     return row(name, `${LEVEL_NOTES[name]}${cap ? `, up to ${formatTokens(cap)} tokens` : ''}`);
   };
+  const intro = meter
+    ? `${wash} compresses this conversation into a short brief. Your next /clear then starts a fresh session that begins with it, and the old session stays in /resume.`
+    : `${wash} compresses this conversation into a short brief. Your next /clear then starts a fresh session, and the brief loads with the first message you send there. The old session stays in /resume.`;
   return [
-    '/wash compresses this conversation into a short brief. Your next /clear then starts a fresh session that begins with it, and the old session stays in /resume.',
+    intro,
     '',
     level('light'),
     level('mid'),
@@ -142,21 +180,22 @@ export function helpMessage(used, footer = null) {
     row('discard', 'drop the brief; /clear is a normal clear again'),
     row('load [id]', 'make a waiting brief the one /clear uses'),
     '',
-    "The status line shows how many tokens this conversation is using, and the bar shows how close that is to the model's limit.",
-    'Writing a brief is an ordinary Claude reply, so it uses tokens. help, discard and load do not.',
+    ...(meter ? ["The status line shows how many tokens this conversation is using, and the bar shows how close that is to the model's limit."] : []),
+    ...(replyMeter ? ["The line after each reply shows how many tokens this conversation is using, and the bar shows how close that is to the model's limit. It is shown to you only and costs no tokens."] : []),
+    `Writing a brief is an ordinary ${model} reply, so it uses tokens. help, discard and load do not.`,
     ...(footer ? ['', footer] : []),
   ].join('\n');
 }
 
 // Shown to the user when briefs are waiting but none was loaded.
-export function pointerMessage(records, now, why) {
+export function pointerMessage(records, now, why, tool = 'claude') {
   const one = records.length === 1;
   const listed = records.slice(0, 3).map((record) => describe(record, now));
   if (records.length > 3) listed.push(`and ${records.length - 3} more`);
   return (
     `Carwash: ${one ? 'a brief is' : `${records.length} briefs are`} waiting for this folder. ` +
     `${one ? 'It was not' : 'None was'} loaded because ${why}. ${listed.join(' · ')}. ` +
-    `To use ${one ? 'it' : 'one'}: /wash load ${one ? records[0].id : '<id>'}, then /clear.`
+    `To use ${one ? 'it' : 'one'}: ${toolInfo(tool).wash} load ${one ? records[0].id : '<id>'}, then /clear.`
   );
 }
 
@@ -167,7 +206,7 @@ export function composeContext(record, now, stale) {
   return [
     '# Carwash handoff',
     '',
-    `The user ran /wash in an earlier session and started this one to carry on from it. The brief below (${record.level}, written ${ageOf(record, now)}) is what that session handed over. The earlier conversation is not available to you.`,
+    `The user ran ${toolInfo(toolOf(record)).wash} in an earlier session and started this one to carry on from it. The brief below (${record.level}, written ${ageOf(record, now)}) is what that session handed over. The earlier conversation is not available to you.`,
     'If the brief is cut off below, or a note says the full text was saved to a file, read that file in full before you reply.',
     'Check the current state of a file before acting on what the brief says about it.',
     ...(stale ? [stale] : []),