context-carwash 0.2.2 → 0.2.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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.

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
 
@@ -96,7 +96,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 +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
 
@@ -118,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.2",
+  "version": "0.2.3",
   "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,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');
 

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/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,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

@@ -11,6 +11,7 @@ import { budgetNote, composeContext, describe, helpMessage, loadedMessage, parse
 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';
@@ -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));
 }