context-carwash 0.2.1 → 0.2.3

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.2.3
+
+- A fresh session can now search the old conversation. When a brief is saved, Carwash keeps a text copy of the conversation in `~/.carwash/recall`, without images, and tells the fresh session where it is, so it can look up an exact error message, path or number the brief left out. The copy is deleted after 7 days, or when you discard the brief. Nothing goes in your project.
+- `install` adds one permission to `~/.claude/settings.json` so Claude can search that folder without asking. It allows reading that folder and nothing else, and `uninstall` takes it out. `carwash doctor` checks it. Run `npx context-carwash@latest install` to get it.
+- `carwash stats` now gives the right cached price on Claude: a twentieth of the normal input price on Opus 5.5 and Sonnet 5.5, not a tenth.
+
+## 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

@@ -25,7 +25,7 @@ It shows you what it's going to change and asks before doing anything. Then star
 
 When there's a new version, a line under the meter will tell you. To update, run `npx context-carwash@latest install`.
 
-Under the hood, it adds a status line and three hooks to `~/.claude/settings.json` (after whatever you already have there) and a `/wash` command in `~/.claude/skills/wash`. For Codex, it adds three hooks to `~/.codex/hooks.json` and a `$wash` command in `~/.codex/skills/wash`.
+Under the hood, it adds a status line, three hooks and one read-only permission to `~/.claude/settings.json` (after whatever you already have there) and a `/wash` command in `~/.claude/skills/wash`. The permission lets Claude search `~/.carwash/recall` without asking, and nothing else. For Codex, it adds three hooks to `~/.codex/hooks.json` and a `$wash` command in `~/.codex/skills/wash`.
 
 ## The Meter
 
@@ -40,7 +40,7 @@ The number is roughly how many tokens your conversation is using (Claude Code's
 1. Type `/wash`. Claude writes a short brief: what you're working on, where things stand, and what's next. The status line switches to `Brief ready ✓`.
 2. Type `/clear`. Your new session starts with the brief already loaded.
 
-Your old conversation isn't gone. You can still find it in `/resume`.
+Your old conversation isn't gone. You can still find it in `/resume`, and the fresh session can search a text copy of it when it needs an exact detail the brief left out, like an error message or a file path. It only searches when it needs to, so otherwise it costs nothing extra.
 
 | Command | What it does |
 |---|---|
@@ -60,7 +60,7 @@ A few things worth knowing:
 - Writing a brief is a normal Claude reply, so it uses some tokens. `help`, `discard` and `load` are free.
 - Bigger conversations get bigger briefs. `/wash help` shows the size limit for each level.
 - Closed the terminal before you got to `/clear`? Run `claude` in the same folder and your brief loads. If there's more than one waiting, it'll list them so you can pick with `/wash load <id>`.
-- Briefs expire after 48 hours.
+- Briefs expire after 48 hours. The text copy of the conversation is deleted after 7 days, or as soon as you discard the brief.
 
 ## Codex
 
@@ -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 a fraction of the price: a twentieth of the normal input price on Opus 5.5 and Sonnet 5.5, and about a tenth on most older models. So in dollars you're saving that fraction 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.
 
@@ -106,7 +110,7 @@ This checks that everything's still installed and working, and shows your versio
 
 ## Where things are kept
 
-Your briefs, stats and error logs live in `~/.carwash`, and only you can read them. Nothing about you gets uploaded. Once a day, Carwash checks npm for a newer version. If you'd rather it didn't, set `CARWASH_NO_UPDATE_CHECK=1`.
+Your briefs, stats, error logs and the text copies of old conversations live in `~/.carwash`, and only you can read them. Nothing goes in your project folders. The text copies leave out images, so they're small: usually under a megabyte each. Nothing about you gets uploaded. Once a day, Carwash checks npm for a newer version. If you'd rather it didn't, set `CARWASH_NO_UPDATE_CHECK=1`.
 
 ## Uninstall
 
@@ -114,7 +118,7 @@ Your briefs, stats and error logs live in `~/.carwash`, and only you can read th
 npx context-carwash uninstall
 ```
 
-This puts `settings.json` back exactly as it was. If you've edited the file since installing, it only removes Carwash's status line and hooks and leaves your changes alone. Codex's `hooks.json` gets the same treatment. It also removes the `/wash` and `$wash` commands and deletes `~/.carwash`, including any waiting briefs and your stats.
+This puts `settings.json` back exactly as it was. If you've edited the file since installing, it only removes Carwash's status line, hooks and permission and leaves your changes alone. Codex's `hooks.json` gets the same treatment. It also removes the `/wash` and `$wash` commands and deletes `~/.carwash`, including any waiting briefs, text copies and your stats.
 
 ## Platforms
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-carwash",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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/install/doctor.mjs

@@ -7,7 +7,7 @@ import { errorLogPath, errorsSeenPath, installRecordPath, settingsPath, skillDir
 import { refreshLedger, totals } from '../stats/ledger.mjs';
 import { readyRecords } from '../wash/store.mjs';
 import { codexDetected, codexHooksCheck, codexSkillInstalled } from './codex.mjs';
-import { commandProgram, isCarwashCommand, isCarwashHook } from './install.mjs';
+import { commandProgram, isCarwashCommand, isCarwashHook, recallRule } from './install.mjs';
 import { UPDATE_COMMAND } from './notice.mjs';
 import { readSettings, resolveSettingsFile } from './settings.mjs';
 import { isNewer } from './update.mjs';
@@ -77,7 +77,8 @@ function settingsCheck(env) {
   const hooks = Object.fromEntries(HOOK_EVENTS.map((event) => [event, groups(event).some((group) => Array.isArray(group?.hooks) && group.hooks.some((hook) => isCarwashHook(hook?.command)))]));
   const hookCommands = HOOK_EVENTS.flatMap((event) => groups(event).flatMap((group) => (Array.isArray(group?.hooks) ? group.hooks.map((hook) => hook?.command) : [])));
   const ours = [data?.statusLine?.command, ...hookCommands].filter((command) => isCarwashCommand(command) || isCarwashHook(command));
-  return { readable: true, statusLine: isCarwashCommand(data?.statusLine?.command), hooks, nodes: [...new Set(ours.map(commandProgram).filter(Boolean))] };
+  const allow = data?.permissions?.allow;
+  return { readable: true, statusLine: isCarwashCommand(data?.statusLine?.command), hooks, recall: Array.isArray(allow) && allow.includes(recallRule(env)), nodes: [...new Set(ours.map(commandProgram).filter(Boolean))] };
 }
 
 // The Node that Carwash's commands start. Install writes its path into the
@@ -135,6 +136,7 @@ export function doctorReport({ env = process.env, now = Date.now(), running, new
       } else {
         out.push(row('Status line', yes(check.statusLine)));
         out.push(row('Hooks', HOOK_EVENTS.map((event) => `${event} ${yes(check.hooks[event])}`).join(' · ')));
+        out.push(row('Session search', check.recall ? 'ok' : `MISSING: Claude will ask before searching an old session · to fix: ${UPDATE_COMMAND}`));
         nodes.push(...check.nodes);
       }
       out.push(row('/wash command', yes(existsSync(join(skillDir(env), 'SKILL.md')))));

package/src/install/install.mjs

@@ -3,7 +3,7 @@ import { homedir } from 'node:os';
 import { delimiter, dirname, join, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { privateDir, readJson, writeFileAtomic } from '../files.mjs';
-import { carwashHome, claudeConfigDir, installRecordPath, legacyCommandPath, pendingDir, settingsPath, skillDir } from '../paths.mjs';
+import { RECALL_DAYS, carwashHome, claudeConfigDir, installRecordPath, legacyCommandPath, pendingDir, recallDir, settingsPath, skillDir } from '../paths.mjs';
 import { applyCodexInstall, applyCodexUninstall, codexDetected, describeCodexInstall, describeCodexUninstall, planCodexInstall, planCodexUninstall } from './codex.mjs';
 import { UserError, readSettings, resolveSettingsFile, serializeSettings, sha256 } from './settings.mjs';
 
@@ -128,6 +128,37 @@ function withCarwashHooks(hooks, command, file) {
   return next;
 }
 
+// The one permission Carwash adds: reading the saved copies of old sessions, so
+// that a fresh session can search them without asking. A Read rule also covers
+// Grep and read-only shell commands such as grep, and it allows nothing else.
+export function recallRule(env = process.env) {
+  const posix = (path) => path.replace(/\\/g, '/').replace(/^([A-Za-z]):/, (_, drive) => `/${drive.toLowerCase()}`);
+  const dir = recallDir(env);
+  const path = dir.startsWith(homedir() + sep) ? `~/${posix(dir.slice(homedir().length + 1))}` : `/${posix(dir)}`;
+  return `Read(${path}/**)`;
+}
+
+// The `permissions` setting with that rule taken out. `allow`, or the whole
+// setting, goes too if it only existed to hold ours. Returns the same object
+// when the rule was not there.
+function withoutRecallRule(permissions, rule) {
+  if (!isPlainObject(permissions) || !Array.isArray(permissions.allow) || !permissions.allow.includes(rule)) return permissions;
+  const { allow, ...others } = permissions;
+  const theirs = allow.filter((entry) => entry !== rule);
+  const next = theirs.length ? { ...permissions, allow: theirs } : others;
+  return Object.keys(next).length ? next : undefined;
+}
+
+// The `permissions` setting with the rule added after whatever is there. One
+// Carwash cannot read is left as it is: a fresh session then asks before it
+// searches, which is all that is lost.
+function withRecallRule(permissions, rule) {
+  if (permissions !== undefined && !isPlainObject(permissions)) return permissions;
+  if (permissions?.allow !== undefined && !Array.isArray(permissions.allow)) return permissions;
+  const theirs = withoutRecallRule(permissions, rule);
+  return { ...theirs, allow: [...(theirs?.allow ?? []), rule] };
+}
+
 function isOurSkill(file) {
   try {
     return readFileSync(file, 'utf8').includes(SKILL_MARK);
@@ -207,14 +238,18 @@ function planClaudeInstall({ env, record, script }) {
   }
 
   const theirHooks = withoutCarwashHooks(settings.data.hooks);
+  const rule = recallRule(env);
+  const permissions = withRecallRule(settings.data.permissions, rule);
   const next = {
     ...settings.data,
     statusLine: { refreshInterval: REFRESH_SECONDS, ...(original ?? {}), type: 'command', command: commandFor('statusline', script) },
     hooks: withCarwashHooks(settings.data.hooks, commandFor('hook', script), file),
+    ...(permissions === undefined ? {} : { permissions }),
   };
   const skill = planSkill(env);
+  const recall = Array.isArray(permissions?.allow) && permissions.allow.includes(rule) ? recallDir(env) : null;
 
-  return { file, settings, claudeRecord: record, original, alreadyInstalled, next, skill, keepsHooks: isPlainObject(theirHooks) && Object.keys(theirHooks).length > 0 };
+  return { file, settings, claudeRecord: record, original, alreadyInstalled, next, skill, recall, keepsHooks: isPlainObject(theirHooks) && Object.keys(theirHooks).length > 0 };
 }
 
 export function describeInstall(plan) {
@@ -224,6 +259,7 @@ export function describeInstall(plan) {
   if (plan.codex) lines.push(...describeCodexInstall(plan.codex, plan.claude ? 4 : 2, plan.home));
   const model = plan.claude && plan.codex ? 'Claude or Codex' : plan.codex ? 'Codex' : 'Claude';
   lines.push('', `Writing a brief is an ordinary ${model} reply, so it uses tokens like any other.`);
+  lines.push(`Each brief also saves a text copy of the conversation in ${tilde(join(plan.home, 'recall'))} for ${RECALL_DAYS} days, so the fresh session can search it for exact details.`);
   // Version managers such as nvm keep a folder per Node version, so removing
   // an old version takes this path with it, and nothing of Carwash can start.
   if (plan.node) lines.push(`Carwash runs with the Node at ${tilde(plan.node)}. If you remove that Node later, for example an old version in nvm, run install again.`);
@@ -250,6 +286,7 @@ function describeClaudeInstall(plan) {
   }
   lines.push('       Adds three hooks, so /wash can save a brief and a fresh session can');
   lines.push(`       pick it up.${plan.keepsHooks ? ' The hooks you already have are kept as they are.' : ''}`);
+  if (plan.recall) lines.push(`       Lets Claude read ${tilde(plan.recall)} without asking, and nothing else.`);
   if (plan.settings.exists && !plan.claudeRecord) {
     lines.push(`       A backup of the file is kept in ${tilde(join(plan.home, 'backup'))}`);
   }
@@ -362,6 +399,12 @@ export function planUninstall({ env = process.env } = {}) {
         else data.hooks = hooks;
         changed = true;
       }
+      const permissions = withoutRecallRule(data.permissions, recallRule(env));
+      if (permissions !== data.permissions) {
+        if (permissions === undefined) delete data.permissions;
+        else data.permissions = permissions;
+        changed = true;
+      }
       if (changed) {
         plan.action = 'edit';
         plan.bytes = serializeSettings(data, settings);
@@ -395,7 +438,7 @@ export function describeUninstall(plan) {
   const what = {
     restore: `Restore ${tilde(plan.file)} to exactly what it was before install`,
     delete: `Delete ${tilde(plan.file)} (Carwash created it and it has not changed since)`,
-    edit: `Edit ${tilde(plan.file)}: undo Carwash's status line and hooks; your other changes stay`,
+    edit: `Edit ${tilde(plan.file)}: undo Carwash's status line, hooks and read rule; your other changes stay`,
     none: `Leave ${tilde(plan.file)} alone`,
   }[plan.action];
   const steps = [];

package/src/paths.mjs

@@ -31,6 +31,12 @@ 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');
 
+// A text copy of the session each brief came from, for the fresh session to
+// search. Kept for a week.
+export const RECALL_DAYS = 7;
+export const recallDir = (env = process.env) => join(carwashHome(env), 'recall');
+export const recallFile = (env, id) => join(recallDir(env), `${id}.log`);
+
 // The savings ledger behind `carwash stats`: one file per brief written.
 export const statsDir = (env = process.env) => join(carwashHome(env), 'stats');
 
@@ -60,3 +66,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/skill/SKILL.md

@@ -7,7 +7,7 @@ metadata:
   installed-by: context-carwash
 ---
 
-The user typed /wash. They want to start a fresh session that picks up where this one leaves off. Your whole reply to this message is saved as the handoff brief, and it is the first thing the next session reads. That session cannot see this conversation, so anything the brief leaves out is gone.
+The user typed /wash. They want to start a fresh session that picks up where this one leaves off. Your whole reply to this message is saved as the handoff brief, and it is the first thing the next session reads. That session cannot see this conversation. It can search a saved copy for an exact detail, but only if it knows to look, so the brief has to stand on its own.
 
 Arguments: $ARGUMENTS
 

package/src/skill/codex/SKILL.md

@@ -9,7 +9,7 @@ The user typed $wash. Context Carwash saves your reply as a handoff brief, but o
 
 **First, look for that message.** If this turn has no developer message starting with "Carwash: level", the hooks are not running and a brief would be lost. Then do not write a brief. Reply with only this: "Carwash's hooks aren't running in Codex yet, so no brief was saved. Restart Codex and choose "Trust all and continue" when it asks about hooks, then run $wash again. If that doesn't help, run `npx context-carwash doctor` in a terminal."
 
-When the message is there: the user wants to start a fresh session that picks up where this one leaves off. Your whole reply to this message is saved as the handoff brief, and it is the first thing the next session reads. That session cannot see this conversation, so anything the brief leaves out is gone.
+When the message is there: the user wants to start a fresh session that picks up where this one leaves off. Your whole reply to this message is saved as the handoff brief, and it is the first thing the next session reads. That session cannot see this conversation. It can search a saved copy for an exact detail, but only if it knows to look, so the brief has to stand on its own.
 
 The words after $wash in the user's message are the arguments. The first word is the level: `light`, `mid`, or `detailed`. No arguments means `mid`. Anything after the level is the user's note on what to emphasise.
 

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 : []);
+
+export 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,13 +44,14 @@ 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.'
+      ? 'Claude caches repeated context and charges far less for it: a twentieth of the normal input price on Opus 5.5 and Sonnet 5.5, a tenth on most older models. In money terms the saving is that share 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',
@@ -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/brief.mjs

@@ -1,4 +1,5 @@
 import { CHARS_PER_TOKEN, capFor } from '../levels.mjs';
+import { RECALL_DAYS } from '../paths.mjs';
 import { colorAt, paint } from '../statusline/color.mjs';
 import { formatTokens } from '../statusline/render.mjs';
 import { toolInfo, toolOf } from '../tools.mjs';
@@ -183,6 +184,7 @@ export function helpMessage(used, footer = null, tool = 'claude') {
     ...(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.`,
+    `The old conversation is also saved as plain text for ${RECALL_DAYS} days, so the fresh session can search it for an exact detail the brief left out.`,
     ...(footer ? ['', footer] : []),
   ].join('\n');
 }
@@ -202,11 +204,15 @@ export function pointerMessage(records, now, why, tool = 'claude') {
 // What the fresh session's model is given. The framing is kept short: when the
 // whole thing is over Claude Code's limit for hook output, only the first 2,000
 // characters arrive inline, and the brief's Core section has to be among them.
-export function composeContext(record, now, stale) {
+// `recall` is the saved copy of the earlier conversation, when there is one.
+export function composeContext(record, now, stale, recall = null) {
+  const earlier = recall
+    ? `The brief is a summary; the earlier conversation is saved as plain text at ${recall}. When you need an exact detail it leaves out (an error message, path, number, command, or what the user said), search that file with grep instead of guessing, writing its full path in each command rather than in a shell variable. Do not read it whole.`
+    : 'The earlier conversation is not available to you.';
   return [
     '# Carwash handoff',
     '',
-    `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.`,
+    `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. ${earlier}`,
     '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] : []),

package/src/wash/hooks.mjs

@@ -4,13 +4,14 @@ 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';
 import { codexProcess, codexUnattended, currentProcess, isRunning, sameProcess } from './process.mjs';
+import { keptRecall, saveRecall } from './recall.mjs';
 import { readCodexReplyUsage, readCodexUsage, readCodexVersion } from './rollout.mjs';
 import { currentWash, endWash, loadUsage, startWash } from './session.mjs';
 import { AUTO_LOAD_MS, addRecord, claim, findRecords, purge, readyRecords, removeRecord, reopen, updateRecord } from './store.mjs';
@@ -93,7 +94,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)}`);
 }
@@ -236,6 +237,7 @@ function onStop(payload, ctx) {
     now,
   );
   quietly(ctx, () => recordWash(env, record, wash));
+  quietly(ctx, () => saveRecall(env, record.id, payload.transcript_path, ctx.tool));
   // 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)) {
@@ -257,7 +259,7 @@ function deliver(record, payload, ctx) {
   const stale = stalenessLine(record.source, repoState(cwdOf(payload)));
   return {
     systemMessage: loadedMessage(record, now, stale, ctx.tool),
-    hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: composeContext(record, now, stale) },
+    hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: composeContext(record, now, stale, keptRecall(env, record.id)) },
   };
 }
 

package/src/wash/recall.mjs

@@ -0,0 +1,151 @@
+import { closeSync, existsSync, openSync, readSync } from 'node:fs';
+import { StringDecoder } from 'node:string_decoder';
+import { privateDir, writeFileAtomic } from '../files.mjs';
+import { recallDir, recallFile } from '../paths.mjs';
+import { resultText } from '../stats/ledger.mjs';
+import { toolInfo } from '../tools.mjs';
+
+// A brief is a summary, so it leaves things out: the exact error, the path, the
+// one number that matters. When a brief is saved, the session it came from is
+// copied here as plain text, and the fresh session is told where to find it, so
+// it can search for an exact detail instead of guessing.
+//
+// The session files themselves are poor to search. Theirs can run to hundreds
+// of megabytes and one line of an image can be a megabyte or more, which a single
+// search hit would pull into the conversation. This keeps only the words, ends
+// at the wash so the brief is not in it twice, and wraps long lines. One file per
+// brief, deleted after RECALL_DAYS or when the brief is discarded.
+
+// Longest line kept whole, so one search hit stays a small one.
+const WRAP = 2000;
+const LONG_LINE = new RegExp(`.{1,${WRAP}}`, 'gsu');
+
+// Past this, the oldest part of the session is left out. Real sessions are far
+// smaller once images are gone: a few megabytes at the very most.
+const MAX_BYTES = 16 * 1024 * 1024;
+
+const CHUNK = 1024 * 1024;
+
+// The lines of a file, without holding the whole of it in memory at once.
+function* linesOf(file) {
+  const fd = openSync(file, 'r');
+  try {
+    const buffer = Buffer.alloc(CHUNK);
+    const decoder = new StringDecoder('utf8');
+    let rest = '';
+    for (;;) {
+      const read = readSync(fd, buffer, 0, CHUNK, null);
+      if (!read) break;
+      const lines = (rest + decoder.write(buffer.subarray(0, read))).split('\n');
+      rest = lines.pop();
+      yield* lines;
+    }
+    if (rest) yield rest;
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// One transcript line as [who, text] pairs. Images, and anything else that is
+// not words, come out empty and are dropped.
+function claudeEntries(line) {
+  if ((line.type !== 'user' && line.type !== 'assistant') || line.isMeta || line.isSidechain) return [];
+  const content = line.message?.content;
+  if (typeof content === 'string') return [[line.type, content]];
+  if (!Array.isArray(content)) return [];
+  return content.flatMap((block) => {
+    if (block?.type === 'text') return [[line.type, block.text]];
+    if (block?.type === 'thinking') return [['assistant thinking', block.thinking]];
+    if (block?.type === 'tool_use') return [[`tool call ${block.name}`, JSON.stringify(block.input)]];
+    if (block?.type === 'tool_result') return [[block.is_error ? 'tool result (error)' : 'tool result', resultText(block)]];
+    return [];
+  });
+}
+
+const partsText = (parts) => (Array.isArray(parts) ? parts.map((part) => part?.text ?? '').join('') : '');
+
+// The same for a Codex rollout line. Codex says the format is not a stable
+// interface, so anything unexpected is simply left out.
+function codexEntries(line) {
+  if (line.type !== 'response_item') return [];
+  const item = line.payload;
+  switch (item?.type) {
+    case 'message':
+      return item.role === 'user' || item.role === 'assistant' ? [[item.role, partsText(item.content)]] : [];
+    case 'reasoning':
+      return [['assistant thinking', partsText(item.summary)]];
+    case 'function_call':
+      return [[`tool call ${item.name}`, item.arguments]];
+    case 'custom_tool_call':
+      return [[`tool call ${item.name}`, item.input]];
+    case 'function_call_output':
+    case 'custom_tool_call_output':
+      return [['tool result', typeof item.output === 'string' ? item.output : partsText(item.output)]];
+    default:
+      return [];
+  }
+}
+
+const READERS = {
+  claude: { entries: claudeEntries, isWash: (text) => text.includes('<command-name>/wash</command-name>') || /^\s*\/wash(?![\w-])/.test(text) },
+  codex: { entries: codexEntries, isWash: (text) => /^\s*\$wash(?![\w-])/.test(text) },
+};
+
+// Everything said in a session, up to the last wash.
+function readEntries(file, tool) {
+  const { entries: toEntries, isWash } = READERS[tool] ?? READERS.claude;
+  const entries = [];
+  let end = null;
+  for (const raw of linesOf(file)) {
+    let line;
+    try {
+      line = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (!line || typeof line !== 'object') continue;
+    for (const [who, text] of toEntries(line)) {
+      if (typeof text !== 'string' || !text.trim()) continue;
+      if (who === 'user' && isWash(text)) end = entries.length;
+      entries.push({ who, time: line.timestamp, text });
+    }
+  }
+  return end === null ? entries : entries.slice(0, end);
+}
+
+const wrapped = (text) => text.split('\n').map((line) => (line.length > WRAP ? line.match(LONG_LINE).join('\n') : line)).join('\n');
+
+function render(entries, tool) {
+  const kept = [];
+  let bytes = 0;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const { who, time, text } = entries[i];
+    const block = `--- #${i + 1} ${who}${time ? ` ${time}` : ''} ---\n${wrapped(text)}\n\n`;
+    bytes += Buffer.byteLength(block);
+    if (bytes > MAX_BYTES) break;
+    kept.push(block);
+  }
+  const { name, wash } = toolInfo(tool);
+  const dropped = entries.length - kept.length;
+  const note = dropped ? ` The first ${dropped === 1 ? 'entry is' : `${dropped} entries are`} left out too, to keep this file small.` : '';
+  return `A text copy of an earlier ${name} session, saved when ${wash} wrote its brief. Images are left out.${note}\nEach entry starts with a "--- #n who time ---" line.\n\n${kept.reverse().join('')}`;
+}
+
+// Copy a session to the file for brief `id`. Returns that file, or null if
+// there was nothing to copy. The brief works without it, so a caller should not
+// let a failure here stop anything.
+export function saveRecall(env, id, transcript, tool = 'claude') {
+  if (typeof transcript !== 'string' || !existsSync(transcript)) return null;
+  const entries = readEntries(transcript, tool);
+  if (!entries.length) return null;
+  privateDir(recallDir(env));
+  const file = recallFile(env, id);
+  writeFileAtomic(file, render(entries, tool), 0o600);
+  return file;
+}
+
+// The copy for brief `id`, or null if it is gone.
+export function keptRecall(env, id) {
+  const file = recallFile(env, id);
+  return existsSync(file) ? file : null;
+}

package/src/wash/store.mjs

@@ -1,8 +1,8 @@
 import { randomBytes } from 'node:crypto';
-import { existsSync, readdirSync, renameSync, statSync, unlinkSync } from 'node:fs';
+import { existsSync, readdirSync, renameSync, rmSync, statSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
 import { privateDir, readJson, writePrivateJson } from '../files.mjs';
-import { consumedDir, pendingDir, sessionsDir } from '../paths.mjs';
+import { RECALL_DAYS, consumedDir, pendingDir, recallDir, recallFile, sessionsDir } from '../paths.mjs';
 
 // The store of handoff briefs. One JSON file per brief, outside any project:
 // pending/ holds briefs waiting for a fresh session, consumed/ holds delivered
@@ -62,7 +62,9 @@ export function updateRecord(env, record) {
   if (existsSync(file)) writePrivateJson(file, record);
 }
 
+// Drop a waiting brief, and the copy of its session along with it.
 export function removeRecord(env, id) {
+  rmSync(recallFile(env, id), { force: true });
   try {
     unlinkSync(fileIn(pendingDir(env), id));
     return true;
@@ -132,7 +134,7 @@ function sweep(dir, isDue) {
 }
 
 // Delete what has outlived its use: expired briefs, delivered briefs past
-// their retention, old session notes, and stray files.
+// their retention, old session notes and copies, and stray files.
 export function purge(env, now = Date.now()) {
   const setting = (env.CARWASH_RETAIN_HOURS ?? '').trim();
   const retainMs = (setting !== '' && Number(setting) >= 0 ? Number(setting) : RETAIN_HOURS) * HOUR;
@@ -148,4 +150,5 @@ export function purge(env, now = Date.now()) {
     return Number.isFinite(consumed) ? now - consumed > retainMs : stale(file, HOUR);
   });
   sweep(sessionsDir(env), (file) => stale(file, SESSION_NOTE_MS));
+  sweep(recallDir(env), (file) => stale(file, RECALL_DAYS * 24 * HOUR));
 }