context-carwash 0.2.2 → 0.2.5

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.2.5
+
+- After you update, your next session says what's new, once, in Claude Code and in Codex. It waits for a start with nothing else to say, so it never gets in the way of a brief loading. Updating from 0.2.3 or earlier, it tells you about notes on what to keep.
+- The welcome you see after installing now shows how to name what a brief must keep.
+- The README shows notes in the command table, near the top, and in the Codex section.
+
+## 0.2.4
+
+- You can name what a brief must keep: `/wash keep the exact error and the rollback plan`. Claude puts it in a **Kept on request** section right after Core, keeps exact wording for errors, commands and paths, and cuts other sections first when the brief is too long. A note on its own gets a `mid` brief; to pick the level, put it first, as in `/wash detailed keep the test names`. The same works with `$wash` in Codex.
+- A note can start with a word that is also a command: `/wash help me keep the API notes` writes a brief instead of showing help. `help` and `stats` are commands only when nothing follows them, and `load` and `discard` only with at most an id.
+- Likely typos cost nothing: `/wash detaled` or `/wash discrad a3f9c2` asks "Did you mean…?" instead of writing a brief.
+- `/wash help` shows how to add a note.
+- Run `npx context-carwash@latest install` to get the new `/wash` instructions.
+
+## 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.

package/README.md

@@ -7,7 +7,7 @@
 Context Carwash adds a line to Claude Code in your terminal that:
 
 1. **The Meter:** shows the current conversation's context size.
-2. **/wash:** lets you compress your context and start a new session without losing important details.
+2. **/wash:** lets you compress your context and start a new session without losing important details. You can name anything it must keep: `/wash keep the exact error`.
 
 It works in Codex too: see [Codex](#codex).
 
@@ -23,9 +23,9 @@ npx context-carwash install
 
 It shows you what it's going to change and asks before doing anything. Then start a new Claude Code session and you're set. If you use Codex as well, it sets that up in the same go.
 
-When there's a new version, a line under the meter will tell you. To update, run `npx context-carwash@latest install`.
+When there's a new version, a line under the meter will tell you. To update, run `npx context-carwash@latest install`. Your next session after updating tells you what's new, once.
 
-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 |
 |---|---|
@@ -48,6 +48,7 @@ Your old conversation isn't gone. You can still find it in `/resume`.
 | `/wash light` | Goal, current state, next step |
 | `/wash mid` | Adds constraints, decisions, state detail, pitfalls |
 | `/wash detailed` | Adds rationale, history, test results, risks, a step checklist |
+| `/wash keep the exact error` | Write a `mid` brief that also keeps what you name, in its own section |
 | `/wash discard` | Drop the brief. `/clear` is a normal clear again |
 | `/wash load [id]` | Make a waiting brief the one your next `/clear` uses |
 | `/wash stats` | How much context your washes have saved |
@@ -55,18 +56,18 @@ Your old conversation isn't gone. You can still find it in `/resume`.
 
 A few things worth knowing:
 
-- You can tell Claude what to focus on: `/wash mid focus on the failing test`.
+- A note on what to keep goes in its own section near the top of the brief and is never cut to save space. For a level other than `mid`, put the level first: `/wash detailed keep the test names`.
 - If you `/clear` without a brief ready, it's just a normal clear.
 - 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
 
 If you have Codex, `install` sets it up too. It works the same way, with a few differences:
 
-- The command is `$wash` (Codex keeps `/` for its own commands). Same options: `$wash light`, `$wash discard`, `$wash help` and so on.
+- The command is `$wash` (Codex keeps `/` for its own commands). Same options: `$wash light`, `$wash keep the exact error`, `$wash discard`, `$wash help` and so on.
 - Codex asks you to approve new hooks before it runs them. The first time you start Codex after installing, choose **Trust all and continue**.
 - After `/clear`, send your next message (even just "continue"). The brief loads with it, because that's when Codex starts the new session.
 - The meter shows up as a line after each reply, because Codex's status line can only show its own items:
@@ -96,7 +97,7 @@ Every request to Claude or Codex sends the whole conversation again. After a was
 
 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`.
+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.
 
@@ -110,7 +111,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
 
@@ -118,7 +119,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.2",
+  "version": "0.2.5",
   "description": "A quiet context meter and deliberate fresh-session handoff for Claude Code and Codex.",
   "license": "MIT",
   "repository": {

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,9 +3,10 @@ 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, updatedFromPath } from '../paths.mjs';
 import { applyCodexInstall, applyCodexUninstall, codexDetected, describeCodexInstall, describeCodexUninstall, planCodexInstall, planCodexUninstall } from './codex.mjs';
 import { UserError, readSettings, resolveSettingsFile, serializeSettings, sha256 } from './settings.mjs';
+import { isNewer } from './update.mjs';
 
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
 const APP_ENTRIES = ['bin', 'src', 'package.json', 'LICENSE'];
@@ -128,6 +129,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 +239,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 +260,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 +287,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'))}`);
   }
@@ -279,6 +317,19 @@ export function applyInstall(plan) {
   const extra = { ...(tools.length === 1 && tools[0] === 'claude' ? {} : { tools }), ...(codex ? { codex } : {}) };
   const nextRecord = plan.claude ? { ...base, ...applyClaudeInstall(plan), ...extra } : { ...base, ...extra };
   writeFileSync(installRecordPath({ CARWASH_HOME: home }), JSON.stringify(nextRecord, null, 2) + '\n', { mode: 0o600 });
+
+  // An update notes the version it replaced, so the next session in each tool
+  // can say what is new. Installing again before that session keeps the first
+  // note, which goes back further.
+  if (record?.version && isNewer(base.version, record.version)) {
+    for (const tool of tools) {
+      try {
+        writeFileSync(updatedFromPath({ CARWASH_HOME: home }, tool), `${record.version}\n`, { flag: 'wx', mode: 0o600 });
+      } catch {
+        // already noted
+      }
+    }
+  }
   return nextRecord;
 }
 
@@ -362,6 +413,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 +452,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');
 
@@ -51,6 +57,10 @@ export const noticePath = (env = process.env) => join(carwashHome(env), 'notice.
 // Present once the first-run welcome has been shown. Each tool says hello once.
 export const welcomedPath = (env = process.env, tool = 'claude') => join(carwashHome(env), tool === 'claude' ? 'welcomed' : `welcomed-${tool}`);
 
+// Left by an install that updated Carwash: the version it replaced. The next
+// session in each tool says what is new since then, once, and deletes it.
+export const updatedFromPath = (env = process.env, tool = 'claude') => join(carwashHome(env), tool === 'claude' ? 'updated-from' : `updated-from-${tool}`);
+
 // Where the /wash command is installed.
 export const skillDir = (env = process.env) => join(claudeConfigDir(env), 'skills', 'wash');
 export const legacyCommandPath = (env = process.env) => join(claudeConfigDir(env), 'commands', 'wash.md');

package/src/skill/SKILL.md

@@ -1,17 +1,17 @@
 ---
 name: wash
 description: Context Carwash. Writes a short handoff brief of this session, so that /clear can start a fresh session that carries on from it.
-argument-hint: "[light | mid | detailed | discard | load <id> | stats | help]"
+argument-hint: "[light | mid | detailed] [what to keep] | discard | load <id> | stats | help"
 disable-model-invocation: true
 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
 
-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. If the first word is something else, Carwash's hooks are not running: write no brief, and tell the user in one sentence to run `carwash install` again.
+Carwash's hooks send a line with this command that starts with "Carwash: level". It gives the level for this brief (`light`, `mid`, or `detailed`), its token ceiling, and the user's note on what the brief must keep, if they wrote one. Go by that line, not by the arguments above. If there is no such line, Carwash's hooks are not running: write no brief, and tell the user in one sentence to run `carwash install` again.
 
 Reply with the brief and nothing else: no preamble, no closing remark, no code fence around it. Do not call tools or read files to prepare. Write from what is already in this conversation.
 
@@ -30,9 +30,11 @@ Start with exactly this heading, then the Core section:
 
 Core must stand on its own in under 1,000 characters. A session that reads only Core should still start in the right place.
 
-After Core, add only the sections for the level, and skip any that would be empty:
+If the user wrote a note, put a **Kept on request** section straight after Core, at every level. It holds everything the note asks for that this conversation has, with the exact wording of error messages, commands, paths, and numbers. If the note asks for something this conversation does not have, say so in one line instead of guessing. Never drop or shorten anything here to save space: cut from the other sections instead. Secrets stay out even when the note asks for them.
 
-- `light`: Core only. Add one line for a critical constraint if breaking it would undo the work.
+After that, add only the sections for the level, and skip any that would be empty:
+
+- `light`: no other sections. Add one line for a critical constraint if breaking it would undo the work.
 - `mid`: **Constraints** (the user's corrections and preferences that still apply), **Decisions** (what was settled, with the reason in a clause), **State** (files and branches changed, commands and tests run with their results, uncommitted work, blockers), **Pitfalls** (what to avoid, and approaches that failed).
 - `detailed`: everything in `mid`, plus **Rationale** for the main decisions, **History** (experiments worth knowing about and what each one showed), **Test results**, **Risks and open assumptions**, and **Steps** (a checklist of what remains).
 

package/src/skill/codex/SKILL.md

@@ -9,9 +9,9 @@ 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.
+The "Carwash: level" message gives the level for this brief (`light`, `mid`, or `detailed`), its token ceiling, and the user's note on what the brief must keep, if they wrote one. Go by that message, not by the words after $wash.
 
 Reply with the brief and nothing else: no preamble, no closing remark, no code fence around it. Do not call tools or read files to prepare. Write from what is already in this conversation.
 
@@ -30,9 +30,11 @@ Start with exactly this heading, then the Core section:
 
 Core must stand on its own in under 1,000 characters. A session that reads only Core should still start in the right place.
 
-After Core, add only the sections for the level, and skip any that would be empty:
+If the user wrote a note, put a **Kept on request** section straight after Core, at every level. It holds everything the note asks for that this conversation has, with the exact wording of error messages, commands, paths, and numbers. If the note asks for something this conversation does not have, say so in one line instead of guessing. Never drop or shorten anything here to save space: cut from the other sections instead. Secrets stay out even when the note asks for them.
 
-- `light`: Core only. Add one line for a critical constraint if breaking it would undo the work.
+After that, add only the sections for the level, and skip any that would be empty:
+
+- `light`: no other sections. Add one line for a critical constraint if breaking it would undo the work.
 - `mid`: **Constraints** (the user's corrections and preferences that still apply), **Decisions** (what was settled, with the reason in a clause), **State** (files and branches changed, commands and tests run with their results, uncommitted work, blockers), **Pitfalls** (what to avoid, and approaches that failed).
 - `detailed`: everything in `mid`, plus **Rationale** for the main decisions, **History** (experiments worth knowing about and what each one showed), **Test results**, **Risks and open assumptions**, and **Steps** (a checklist of what remains).
 

package/src/stats/ledger.mjs

@@ -93,7 +93,7 @@ export const sentOf = (usage) => (usage.input_tokens ?? 0) + (usage.cache_read_i
 
 const blocksOf = (line) => (Array.isArray(line.message?.content) ? line.message.content : []);
 
-const resultText = (block) =>
+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.

package/src/stats/report.mjs

@@ -51,7 +51,7 @@ export function statsReport(sum, { inClaude = false } = {}) {
     `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',

package/src/wash/brief.mjs

@@ -1,11 +1,14 @@
+import { isNewer } from '../install/update.mjs';
 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';
 
 // 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.
+// the places Carwash explains itself: the first-run welcome, what is new after
+// an update, and /wash help.
 // Wording that names the tool or its commands takes the tool's id (see
 // tools.mjs); Claude Code is the default.
 
@@ -54,23 +57,26 @@ const sizeOf = (record) => `${record.level} ~${formatTokens(record.tokens)}`;
 // a3f9c2 "Fix login redirect" (mid ~1.1k, 14h ago)
 export const describe = (record, now) => `${record.id} "${record.title}" (${sizeOf(record)}, ${ageOf(record, now)})`;
 
-// Sent to Claude alongside the /wash prompt: the size limit for this brief.
-export function budgetNote(level, cap, used) {
+// Sent to Claude alongside the /wash prompt: the size limit for this brief,
+// and the user's note on what it must keep, if they wrote one.
+export function budgetNote(level, cap, used, note = '') {
+  const kept = note ? ` The user's note on what this brief must keep: ${note}` : '';
   if (!cap) {
-    return `Carwash: level ${level}. The size of this session is not known yet, so there is no token ceiling for this brief. Keep to the ${level} scope and keep it short.`;
+    return `Carwash: level ${level}. The size of this session is not known yet, so there is no token ceiling for this brief. Keep to the ${level} scope and keep it short.${kept}`;
   }
   const chars = Math.max(100, Math.round((cap * CHARS_PER_TOKEN) / 100) * 100);
   return (
     `Carwash: level ${level}. This session is using about ${formatTokens(used)} tokens, so the ceiling for this brief is ${cap} tokens, ` +
-    `which is roughly ${chars} characters. That is a limit, not a target: stop as soon as the brief is complete.`
+    `which is roughly ${chars} characters. That is a limit, not a target: stop as soon as the brief is complete.${kept}`
   );
 }
 
 // Sent to Claude when its brief came out over the cap.
-export function retryNote(level, cap, tokens) {
+export function retryNote(level, cap, tokens, hasNote = false) {
+  const keep = hasNote ? ', the Core section, and everything in Kept on request' : ' and the Core section';
   return (
     `Carwash: that brief is about ${tokens} tokens, over the ${cap}-token ceiling for ${level}. Send it again shortened to fit. ` +
-    'Keep the "# Carwash brief:" heading and the Core section, cut the least useful detail first, and reply with the brief alone.'
+    `Keep the "# Carwash brief:" heading${keep}, cut the least useful detail first, and reply with the brief alone.`
   );
 }
 
@@ -141,6 +147,7 @@ export function welcomeMessage(tool = 'claude') {
       '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',
+      '  • Something the brief must keep? Name it: $wash keep the exact error',
       '  • Nothing runs on its own · $wash help for options',
     ].join('\n');
   }
@@ -148,10 +155,25 @@ export function welcomeMessage(tool = 'claude') {
     'Context Carwash installed ✓ (shown once)',
     '  • Status line: tokens in use, and how full the context is',
     '  • Getting full? /wash, then /clear. You start fresh, right where you left off',
+    '  • Something the brief must keep? Name it: /wash keep the exact error',
     '  • Nothing runs on its own · /wash help for options',
   ].join('\n');
 }
 
+// What a release brings that someone updating should hear about, in the
+// tool's own command. Most releases add nothing here.
+const WHATS_NEW = [
+  ['0.2.4', (wash) => `Name what a brief must keep: ${wash} keep the exact error. It gets its own section and is never cut to save space.`],
+];
+
+// Shown once, at the first quiet session after an update: what is new since
+// `from`, or null when nothing is worth saying.
+export function whatsNewMessage(from, to, tool = 'claude') {
+  const { wash } = toolInfo(tool);
+  const lines = WHATS_NEW.filter(([version]) => isNewer(version, from) && !isNewer(version, to)).map(([, line]) => `  • ${line(wash)}`);
+  return lines.length ? [`Context Carwash updated to ${to} ✓ (shown once)`, ...lines].join('\n') : null;
+}
+
 // What each level keeps, for /wash help.
 const LEVEL_NOTES = {
   light: 'goal, where things stand, next step',
@@ -180,9 +202,12 @@ export function helpMessage(used, footer = null, tool = 'claude') {
     row('discard', 'drop the brief; /clear is a normal clear again'),
     row('load [id]', 'make a waiting brief the one /clear uses'),
     '',
+    `Add a note to name what the brief must keep: ${wash} keep the exact error, or ${wash} detailed keep the test names.`,
+    '',
     ...(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 +227,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

@@ -1,16 +1,17 @@
-import { existsSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
 import { packageVersion } from '../install/install.mjs';
 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 { installRecordPath, updatedFromPath, welcomedPath } from '../paths.mjs';
 import { recordDelivery, recordWash, refreshLedger } from '../stats/ledger.mjs';
 import { colorDepth } from '../statusline/color.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 { budgetNote, composeContext, describe, helpMessage, loadedMessage, parseReply, pointerMessage, readyMessage, replyMeterMessage, retryNote, stalenessLine, welcomeMessage, whatsNewMessage } 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';
@@ -20,9 +21,10 @@ import { AUTO_LOAD_MS, addRecord, claim, findRecords, purge, readyRecords, remov
 //   UserPromptExpansion  /wash was typed (Claude Code). In Codex, where $wash
 //   UserPromptSubmit     is a skill, every prompt comes through
 //                        UserPromptSubmit and only one starting with $wash is
-//                        ours. A level starts a wash and tells the model the
-//                        size limit; discard, load, stats and help are handled
-//                        here and never reach the model.
+//                        ours. A level or a note starts a wash and tells the
+//                        model the size limit and the note; discard, load,
+//                        stats and help are handled here and never reach the
+//                        model.
 //   Stop                 The model finished replying. If that reply is the
 //                        brief, save it. Otherwise, in Codex, show the meter.
 //   SessionStart         A session began. If a brief is meant for it, hand the
@@ -36,7 +38,7 @@ import { AUTO_LOAD_MS, addRecord, claim, findRecords, purge, readyRecords, remov
 
 const usageLine = (tool) => {
   const wash = toolInfo(tool).wash;
-  return `Usage: ${wash} [light | mid | detailed], ${wash} discard [id], ${wash} load [id], ${wash} stats, ${wash} help`;
+  return `Usage: ${wash} [light | mid | detailed] [note on what to keep], ${wash} discard [id], ${wash} load [id], ${wash} stats, ${wash} help`;
 };
 
 // How many times to ask for a shorter brief before keeping an oversized one.
@@ -88,23 +90,59 @@ function onPromptSubmit(payload, ctx) {
   return found ? washCommand(payload, found[1], 'UserPromptSubmit', ctx) : null;
 }
 
+// A first word that is a level, or a command with no more than it takes, is
+// read as one. Anything else of more than a word is the user's note on what
+// the brief must keep, at the default level: "/wash help me keep the API
+// notes" is a note, not help. A lone unknown word, or a near miss of a long
+// name, is taken for a typo and costs nothing.
 function washCommand(payload, args, event, ctx) {
-  const [verb = DEFAULT_LEVEL, ref] = String(args ?? '').trim().toLowerCase().split(/\s+/).filter(Boolean);
-  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(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)}`);
+  const text = String(args ?? '').trim();
+  const words = text.toLowerCase().split(/\s+/).filter(Boolean);
+  const [verb = DEFAULT_LEVEL, ref] = words;
+  if (isLevel(verb)) return begin(payload, verb, text.replace(/^\S+\s*/, ''), event, ctx);
+  if (verb === 'discard' && words.length <= 2) return block(discard(payload, ref, ctx));
+  if (verb === 'load' && words.length <= 2) return block(load(payload, ref, ctx));
+  if (verb === 'stats' && words.length === 1) return block(statsReport(currentTotals(ctx.env, ctx.now), { inClaude: true }));
+  if (verb === 'help' && words.length === 1) return block(helpMessage(ctx.usage(payload)?.used ?? null, versionLine(ctx.version, ctx.env), ctx.tool));
+  const lone = words.length === 1;
+  const guess = meant(verb, lone ? NAMES : LONG_NAMES);
+  if (!lone && !guess) return begin(payload, DEFAULT_LEVEL, text, event, ctx);
+  const { wash } = toolInfo(ctx.tool);
+  const hint = guess ? ` Did you mean ${wash} ${guess}?` : '';
+  return block(`${wash} does not know "${verb}".${hint} For a note on what to keep, put a level first: ${wash} mid <note>. ${usageLine(ctx.tool)}`);
 }
 
-function begin(payload, level, event, ctx) {
+const NAMES = ['light', 'mid', 'detailed', 'discard', 'load', 'stats', 'help'];
+// Short names are a letter away from everyday words ("right", "did", "lead")
+// that may well start a note, so only these are checked there.
+const LONG_NAMES = ['detailed', 'discard'];
+
+// The name a typo was probably meant to be: one slip from a short name, two
+// from a long one, where swapping two letters counts as one.
+function meant(word, names) {
+  return names.find((name) => name !== word && slips(word, name) <= (name.length > 5 ? 2 : 1)) ?? null;
+}
+
+function slips(a, b) {
+  const d = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+  for (let j = 1; j <= b.length; j++) d[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+    }
+  }
+  return d[a.length][b.length];
+}
+
+function begin(payload, level, note, event, ctx) {
   const { env, now } = ctx;
   const usage = ctx.usage(payload);
   const used = usage?.used ?? null;
   const cap = capFor(level, used);
-  startWash(env, payload.session_id, { promptId: promptIdOf(payload), level, cap, used, size: usage?.size ?? null, startedAt: now, rewrites: 0 });
-  return { hookSpecificOutput: { hookEventName: event, additionalContext: budgetNote(level, cap, used) } };
+  startWash(env, payload.session_id, { promptId: promptIdOf(payload), level, cap, used, size: usage?.size ?? null, startedAt: now, rewrites: 0, ...(note ? { hasNote: true } : {}) });
+  return { hookSpecificOutput: { hookEventName: event, additionalContext: budgetNote(level, cap, used, note) } };
 }
 
 // Briefs waiting for the folder this session is in, other than its own. Only
@@ -211,7 +249,7 @@ function onStop(payload, ctx) {
   const overCap = Boolean(wash.cap) && tokens > wash.cap;
   if (overCap && wash.rewrites < MAX_REWRITES) {
     startWash(env, sessionId, { ...wash, rewrites: wash.rewrites + 1 });
-    const note = retryNote(wash.level, wash.cap, tokens);
+    const note = retryNote(wash.level, wash.cap, tokens, wash.hasNote);
     // Codex continues the turn with a Stop's block reason as the next prompt.
     if (ctx.tool === 'codex') return { decision: 'block', reason: note };
     return { hookSpecificOutput: { hookEventName: 'Stop', additionalContext: note } };
@@ -236,6 +274,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 +296,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)) },
   };
 }
 
@@ -275,9 +314,29 @@ function welcome(ctx) {
     // Already shown, or nowhere to note it: better silent than said every time.
     return null;
   }
+  // The welcome already describes this version, so an update note goes with it.
+  rmSync(updatedFromPath(env, tool), { force: true });
   return { systemMessage: welcomeMessage(tool) };
 }
 
+// After an update, the first quiet start in each tool says what is new, once.
+// Deleting the installer's note is the claim, as creating the marker is for
+// the welcome.
+function whatsNew(ctx) {
+  const { env, tool } = ctx;
+  const file = updatedFromPath(env, tool);
+  if (!existsSync(file) || ctx.unattended()) return null;
+  let from;
+  try {
+    from = readFileSync(file, 'utf8').trim();
+    unlinkSync(file);
+  } catch {
+    return null;
+  }
+  const message = whatsNewMessage(from, ctx.version, tool);
+  return message ? { systemMessage: message } : null;
+}
+
 function onSessionStart(payload, ctx) {
   // Only a brand-new conversation gets a brief; a resumed, compacted or
   // forked one already has its own history.
@@ -286,8 +345,9 @@ function onSessionStart(payload, ctx) {
   // be asked through its command line, which on Windows takes a PowerShell
   // run, so it is asked only once a brief or the welcome is at stake.
   if (ctx.tool === 'claude' && ctx.unattended()) return null;
-  // The welcome waits for a start that has nothing else to say.
-  const result = briefAtStart(payload, ctx) ?? welcome(ctx);
+  // The welcome, or what is new since an update, waits for a start that has
+  // nothing else to say.
+  const result = briefAtStart(payload, ctx) ?? welcome(ctx) ?? whatsNew(ctx);
   quietly(ctx, () => ctx.checkUpdates?.());
   let notice = null;
   quietly(ctx, () => (notice = startNotice(ctx.version, ctx.env)));

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));
 }