context-carwash 0.1.5 → 0.1.6

package/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+## 0.1.6
+
+- Update notices: once a day, a new session checks npm in the background. A line under the meter says when a newer version is out, or when the version you have carries a warning. `CARWASH_NO_UPDATE_CHECK=1` turns it off.
+- `carwash doctor`: checks the install and prints versions and recent errors, ready to paste into a bug report.
+- The status line says when a hook has failed, until `doctor` has shown the error.
+- `/wash help` shows the version you have.
+
+## 0.1.5
+
+- `stats --share` sends to the Context Carwash Google Form.
+
+## 0.1.4
+
+- `carwash stats` and `/wash stats`: how much context `/wash` has kept from being sent again, measured from the fresh sessions' transcripts.
+
+## 0.1.3
+
+- An out-of-date installer hands over to the newest release.
+
+## 0.1.2
+
+- The installer says when a newer version is on npm.
+
+## 0.1.1
+
+- Shorter welcome note. Status line hints are sized to the window.
+
+## 0.1.0
+
+- First release on npm: the context meter, the installer and uninstaller, `/wash`, and brief delivery on `/clear`.

package/README.md

@@ -5,7 +5,7 @@ A small, local-first utility for Claude Code.
 - **Meter:** a quiet estimate of the active context window in the status line.
 - **Wash:** when you ask, Claude writes a short handoff brief, and your next `/clear` starts a fresh session that begins with it.
 
-Nothing happens automatically, and nothing leaves your machine. Two exceptions: the installer asks npm whether a newer version is out, and `carwash stats --share` sends anonymous totals if you run it and say yes.
+Nothing happens automatically, and nothing about you is ever sent. Carwash goes online in two ways: once a day it reads its own public page on npm to see if a newer version is out (you can turn that off), and `carwash stats --share` sends anonymous totals if you run it and say yes.
 
 **Status:** pre-release. The meter and the typed `/wash` command work today. Clickable links in the status line and the one-step restart are not built yet. See [plan-3.md](plan-3.md) for the design.
 
@@ -18,7 +18,9 @@ npx context-carwash preview     # sample meters in your terminal, nothing instal
 npx context-carwash install     # lists what it will change, then asks
 ```
 
-To update later, run `npx context-carwash install` again. Waiting briefs are kept. If npx reruns an older copy it downloaded before, the installer notices that npm has a newer version and installs that one instead.
+To update later, run `npx context-carwash@latest install`. Waiting briefs are kept. If npx reruns an older copy it downloaded before, the installer notices that npm has a newer version and installs that one instead.
+
+You do not have to watch for new versions. Once a day, when a session starts, Carwash checks npm in the background. If a newer version is out, or the version you have has a known problem, a line under the meter says so, with the command to update. `/wash help` shows the version you have.
 
 The installer copies itself to `~/.carwash/app` and makes three changes to Claude Code, all listed before you confirm:
 
@@ -106,11 +108,21 @@ npx context-carwash stats --share
 
 This shows every field it would send, and sends only if you say yes. It sends totals to a Google Form: a random share id made for sharing only (so sharing again replaces your last share), the Carwash version, your operating system, days since your first brief, and the numbers above. No names, folders, projects, prompts or briefs. You are not signed in to send it.
 
+## Something not working?
+
+```sh
+npx context-carwash doctor
+```
+
+This checks that the status line, hooks and `/wash` command are still in place, and shows your Carwash, Node, Claude Code and operating system versions, the newest version on npm, and the last few errors. Paste it into a [new issue](https://github.com/Spobi/context-carwash/issues/new).
+
+If a hook fails, the status line shows `Carwash hit an error` until you run `doctor`.
+
 ## Where things are kept
 
-Briefs are stored in `~/.carwash`, readable only by you, and never inside your project. So is the stats ledger (`~/.carwash/stats`): one small file per brief with its size, its level, and which fresh sessions it went to, but never the brief or your prompts. Nothing is uploaded in the background, and there is no telemetry. The installer reads the newest version number from npm (set `CARWASH_NO_UPDATE_CHECK=1` to skip that), and `stats --share` sends only when you run it and say yes.
+Briefs are stored in `~/.carwash`, readable only by you, and never inside your project. So is the stats ledger (`~/.carwash/stats`): one small file per brief with its size, its level, and which fresh sessions it went to, but never the brief or your prompts. Nothing about you is uploaded, and there is no telemetry. Once a day, a new session reads Carwash's public page on npm: the newest version, and any warning about the one you have. That is a download, like opening a web page, and it sends nothing about you, your projects or your use. The answer is kept in `~/.carwash/notice.json`. `install` and `doctor` read the same page when you run them. Set `CARWASH_NO_UPDATE_CHECK=1` to turn all of this off. `stats --share` sends only when you run it and say yes.
 
-If a hook fails it stays silent and writes the error to `~/.carwash/errors.log`.
+If a hook fails it stays silent, writes the error to `~/.carwash/errors.log`, and the status line says so.
 
 ## Uninstall
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-carwash",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "A quiet context meter and deliberate fresh-session handoff for Claude Code.",
   "license": "MIT",
   "repository": {
@@ -21,7 +21,8 @@
   },
   "files": [
     "bin",
-    "src"
+    "src",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "test": "node --test"

package/src/cli.mjs

@@ -1,9 +1,12 @@
 import { appendFileSync, existsSync, statSync, writeFileSync } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { applyInstall, applyUninstall, describeInstall, describeUninstall, packageVersion, planInstall, planUninstall } from './install/install.mjs';
+import { claudeVersion, doctorReport, markErrorsSeen } from './install/doctor.mjs';
+import { fetchNotice, refreshNotice, startCheck } from './install/notice.mjs';
 import { UserError } from './install/settings.mjs';
 import { isNewer, latestVersion, runRelease } from './install/update.mjs';
-import { errorLogPath, welcomedPath } from './paths.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 { render } from './statusline/render.mjs';
@@ -18,6 +21,7 @@ Usage: carwash <command>
   uninstall [--yes]   Undo everything install did
   preview             Print sample meters in this terminal
   stats [--share]     Show how much context /wash has saved; --share sends the totals anonymously, after asking
+  doctor              Check the install and show recent errors, to paste into a bug report
   --version           Print the version
 
 Inside Claude Code, once installed:
@@ -29,8 +33,10 @@ Inside Claude Code, once installed:
   /wash stats                      The same totals as carwash stats
   /wash help                       Explain the meter and the options
 
-Nothing happens automatically. Only two things go online: install, to ask npm
-for the newest version, and stats --share, once you have said yes.`;
+Nothing happens automatically, and nothing about you is ever sent. Once a day a
+new session reads Carwash's public page on npm for the newest version and any
+warning about yours (CARWASH_NO_UPDATE_CHECK=1 turns that off). install and
+doctor read it too. stats --share sends totals only after you say yes.`;
 
 async function readAll(stream) {
   if (stream.isTTY) return '';
@@ -93,7 +99,7 @@ function logError(env, error) {
   }
 }
 
-export async function main(argv, { env = process.env, stdin = process.stdin, stdout = process.stdout, stderr = process.stderr, latest = latestVersion, handOff = runRelease, form = FORM, share = sendShare } = {}) {
+export async function main(argv, { env = process.env, stdin = process.stdin, stdout = process.stdout, stderr = process.stderr, latest = latestVersion, handOff = runRelease, form = FORM, share = sendShare, notice = fetchNotice, claude = claudeVersion, check = startCheck } = {}) {
   const [command, ...rest] = argv;
   const yes = rest.includes('--yes') || rest.includes('-y');
   try {
@@ -104,7 +110,8 @@ export async function main(argv, { env = process.env, stdin = process.stdin, std
       case 'hook': {
         let output = null;
         try {
-          output = runHook({ input: await readAll(stdin), env, onError: (error) => logError(env, error) });
+          const version = packageVersion();
+          output = runHook({ input: await readAll(stdin), env, version, onError: (error) => logError(env, error), checkUpdates: () => check(version, { env }) });
         } catch (error) {
           logError(env, error);
         }
@@ -132,6 +139,8 @@ export async function main(argv, { env = process.env, stdin = process.stdin, std
           return 1;
         }
         applyInstall(plan);
+        // Errors from before this install are not news.
+        markErrorsSeen(env);
         const welcome = existsSync(welcomedPath(env)) ? '' : ' Its first message explains them.';
         stdout.write(`Installed. Start a new Claude Code session to get the meter and /wash.${welcome}\n`);
         return 0;
@@ -176,6 +185,18 @@ export async function main(argv, { env = process.env, stdin = process.stdin, std
       case 'preview':
         preview(env, stdout);
         return 0;
+      case 'doctor': {
+        const running = packageVersion();
+        const installed = readJson(installRecordPath(env))?.version;
+        const newest = await notice(typeof installed === 'string' ? installed : running, { env });
+        stdout.write(doctorReport({ env, running, newest, claude: claude({ env }) }) + '\n');
+        markErrorsSeen(env);
+        return 0;
+      }
+      // Started in the background by a session's start, at most once a day.
+      case 'update-check':
+        await refreshNotice(packageVersion(), { env });
+        return 0;
       case '--version':
       case '-v':
       case 'version':

package/src/install/doctor.mjs

@@ -0,0 +1,136 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { arch, homedir, release } from 'node:os';
+import { join, sep } from 'node:path';
+import { readJson } from '../files.mjs';
+import { errorLogPath, errorsSeenPath, installRecordPath, settingsPath, skillDir } from '../paths.mjs';
+import { refreshLedger, totals } from '../stats/ledger.mjs';
+import { readyRecords } from '../wash/store.mjs';
+import { isCarwashCommand, isCarwashHook } from './install.mjs';
+import { UPDATE_COMMAND } from './notice.mjs';
+import { readSettings, resolveSettingsFile } from './settings.mjs';
+import { isNewer } from './update.mjs';
+
+// `carwash doctor`: everything needed to tell what is wrong, in one block
+// that can be pasted into an issue. It reads, and changes only one thing:
+// the status line stops mentioning errors once they have been shown here.
+
+export const ISSUES_URL = 'https://github.com/Spobi/context-carwash/issues/new';
+const HOOK_EVENTS = ['SessionStart', 'Stop', 'UserPromptExpansion'];
+const RECENT_ERRORS = 3;
+const ERROR_LINES = 8;
+
+const tilde = (text) => text.split(homedir() + sep).join(`~${sep}`);
+
+// Claude Code's own version, or null if `claude` is not on PATH.
+export function claudeVersion({ env = process.env, platform = process.platform } = {}) {
+  try {
+    const result = spawnSync('claude', ['--version'], { env, encoding: 'utf8', timeout: 5000, shell: platform === 'win32', windowsHide: true });
+    const out = (result.stdout ?? '').trim();
+    return result.status === 0 && out ? out.split('\n')[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+// The last few entries of the error log, newest last. Each entry starts with
+// the time it was written; a stack trace follows on the next lines.
+export function recentErrors(env = process.env) {
+  let text;
+  try {
+    text = readFileSync(errorLogPath(env), 'utf8');
+  } catch {
+    return [];
+  }
+  const entries = text.split(/^(?=\d{4}-\d\d-\d\dT)/m).map((entry) => entry.trimEnd()).filter(Boolean);
+  return entries.slice(-RECENT_ERRORS).map((entry) => {
+    const lines = tilde(entry).split('\n');
+    return lines.length > ERROR_LINES ? [...lines.slice(0, ERROR_LINES), '    …'].join('\n') : lines.join('\n');
+  });
+}
+
+function settingsCheck(env) {
+  const file = resolveSettingsFile(settingsPath(env));
+  let data;
+  try {
+    data = readSettings(file).data;
+  } catch {
+    return { readable: false };
+  }
+  const groups = (event) => (Array.isArray(data?.hooks?.[event]) ? data.hooks[event] : []);
+  const hooks = Object.fromEntries(HOOK_EVENTS.map((event) => [event, groups(event).some((group) => Array.isArray(group?.hooks) && group.hooks.some((hook) => isCarwashHook(hook?.command)))]));
+  return { readable: true, statusLine: isCarwashCommand(data?.statusLine?.command), hooks };
+}
+
+const date = (iso) => {
+  const time = Date.parse(iso ?? '');
+  return Number.isFinite(time) ? new Date(time).toLocaleDateString('en-GB', { day: 'numeric', month: 'short', year: 'numeric' }) : null;
+};
+
+// `running` is this copy's version, which under npx may differ from the copy
+// installed in ~/.carwash/app. `newest` is what npm said just now: { latest,
+// warning } or null.
+export function doctorReport({ env = process.env, now = Date.now(), running, newest, claude, platform = process.platform }) {
+  const row = (label, value) => `  ${label.padEnd(18)}${value}`;
+  const record = readJson(installRecordPath(env));
+  const installed = typeof record?.version === 'string' ? record.version : null;
+  const out = ['Context Carwash doctor', ''];
+
+  if (installed) {
+    const when = date(record.installedAt);
+    out.push(row('Installed', `${installed}${when ? ` (first installed ${when})` : ''}`));
+  } else {
+    out.push(row('Installed', 'no (run: npx context-carwash install)'));
+  }
+  if (running && running !== installed) out.push(row('This copy', running));
+  if (env.CARWASH_NO_UPDATE_CHECK) out.push(row('Newest on npm', 'not checked (CARWASH_NO_UPDATE_CHECK is set)'));
+  else if (!newest) out.push(row('Newest on npm', 'could not check (offline?)'));
+  else out.push(row('Newest on npm', `${newest.latest}${installed && isNewer(newest.latest, installed) ? ` · to update: ${UPDATE_COMMAND}` : ''}`));
+  if (newest?.warning) out.push(row('Warning', newest.warning));
+
+  out.push(row('Node', process.version));
+  out.push(row('System', `${platform} ${release()} ${arch()}`));
+  out.push(row('Claude Code', claude ?? 'not found on PATH'));
+
+  if (installed) {
+    const check = settingsCheck(env);
+    const yes = (ok) => (ok ? 'ok' : 'MISSING');
+    if (!check.readable) {
+      out.push(row('Settings', `could not read ${tilde(settingsPath(env))}`));
+    } 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('/wash command', yes(existsSync(join(skillDir(env), 'SKILL.md')))));
+    let waiting = '?';
+    let written = '?';
+    try {
+      waiting = String(readyRecords(env, now).length);
+    } catch {
+      // unreadable store
+    }
+    try {
+      written = String(totals(refreshLedger(env, { now })).washes);
+    } catch {
+      // unreadable ledger
+    }
+    out.push(row('Briefs waiting', waiting));
+    out.push(row('Briefs written', written));
+  }
+
+  const errors = recentErrors(env);
+  out.push('');
+  if (!errors.length) out.push(`Errors: none logged.`);
+  else out.push(`Last ${errors.length === 1 ? 'error' : `${errors.length} errors`} (from ${tilde(errorLogPath(env))}):`, '', ...errors.map((entry) => entry.replace(/^/gm, '  ')));
+  out.push('', `Something wrong? Open an issue and paste everything above: ${ISSUES_URL}`);
+  return out.join('\n');
+}
+
+// The status line has said "hit an error" until now; this was the look.
+export function markErrorsSeen(env = process.env) {
+  try {
+    writeFileSync(errorsSeenPath(env), `${new Date().toISOString()}\n`, { mode: 0o600 });
+  } catch {
+    // nowhere to note it
+  }
+}

package/src/install/notice.mjs

@@ -0,0 +1,140 @@
+import { spawn } from 'node:child_process';
+import { statSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { readJson, writePrivateJson } from '../files.mjs';
+import { errorLogPath, errorsSeenPath, noticePath } from '../paths.mjs';
+import { isNewer } from './update.mjs';
+
+// Whether this copy is out of date, and any warning the author has put on it.
+//
+// At most once a day, a new session starts a background read of Carwash's
+// public page on npm: the newest version, and the `npm deprecate` message for
+// each version, if any. Nothing about the user is sent. The answer is kept in
+// ~/.carwash/notice.json, where the status line and session start read it
+// without going online themselves. CARWASH_NO_UPDATE_CHECK turns all of it off.
+
+const PACKAGE_URL = 'https://registry.npmjs.org/context-carwash';
+const TIMEOUT_MS = 5000;
+const CHECK_EVERY_MS = 24 * 60 * 60 * 1000;
+const MAX_WARNING = 200;
+
+export const UPDATE_COMMAND = 'npx context-carwash@latest install';
+export const DOCTOR_COMMAND = 'npx context-carwash doctor';
+
+const optedOut = (env) => Boolean(env.CARWASH_NO_UPDATE_CHECK);
+
+// Author text goes on the user's screen, so no control characters (escape
+// sequences could restyle or rewrite the terminal) and no essays.
+function cleanWarning(text) {
+  if (typeof text !== 'string') return null;
+  const flat = text.replace(/[\u0000-\u001f\u007f-\u009f]+/g, ' ').replace(/\s+/g, ' ').trim();
+  if (!flat) return null;
+  return flat.length > MAX_WARNING ? `${flat.slice(0, MAX_WARNING - 1)}…` : flat;
+}
+
+// What npm says about `version`: { latest, warning }, or null when it cannot
+// say in time. Offline or odd answers are no answer, never an error.
+export async function fetchNotice(version, { env = process.env, timeoutMs = TIMEOUT_MS } = {}) {
+  if (optedOut(env)) return null;
+  try {
+    // The abbreviated document: dist-tags and per-version deprecation only.
+    const response = await fetch(PACKAGE_URL, { signal: AbortSignal.timeout(timeoutMs), headers: { accept: 'application/vnd.npm.install-v1+json' } });
+    if (!response.ok) return null;
+    const doc = await response.json();
+    const latest = doc?.['dist-tags']?.latest;
+    if (typeof latest !== 'string') return null;
+    return { latest, warning: cleanWarning(doc?.versions?.[version]?.deprecated) };
+  } catch {
+    return null;
+  }
+}
+
+export const readNotice = (env = process.env) => readJson(noticePath(env));
+
+// The background half: ask npm and keep the answer. A failed check keeps the
+// last good answer, so going offline does not hide a warning.
+export async function refreshNotice(version, { env = process.env, now = Date.now(), fetchNotice: ask = fetchNotice } = {}) {
+  const answer = await ask(version, { env });
+  const previous = readNotice(env) ?? {};
+  if (!answer) return previous;
+  const next = { ...previous, checkedAt: new Date(now).toISOString(), version, latest: answer.latest, warning: answer.warning };
+  writePrivateJson(noticePath(env), next);
+  return next;
+}
+
+// Called as a session starts. Starts a check if the last one is a day old,
+// and returns at once: the session never waits for the network. The attempt is
+// noted first, so sessions opened together, or a machine that is offline, try
+// once a day and not on every start.
+export function startCheck(version, { env = process.env, now = Date.now(), run = spawnCheck } = {}) {
+  if (optedOut(env)) return false;
+  const previous = readNotice(env) ?? {};
+  const last = Date.parse(previous.attemptedAt ?? '');
+  if (Number.isFinite(last) && now - last < CHECK_EVERY_MS && now >= last) return false;
+  writePrivateJson(noticePath(env), { ...previous, attemptedAt: new Date(now).toISOString() });
+  run(env);
+  return true;
+}
+
+function spawnCheck(env) {
+  const script = fileURLToPath(new URL('../../bin/carwash.mjs', import.meta.url));
+  const child = spawn(process.execPath, [script, 'update-check'], { env, detached: true, stdio: 'ignore', windowsHide: true });
+  child.on('error', () => {});
+  child.unref();
+}
+
+// What to tell someone running `version`, from what the last check found:
+// { kind: 'warning' | 'update', latest, warning }, or null.
+export function noticeFor(notice, version, env = process.env) {
+  if (optedOut(env) || !notice) return null;
+  const newer = isNewer(notice.latest, version);
+  // A warning is about the version it was read for. After an update it no
+  // longer applies, even before the next check.
+  if (notice.warning && notice.version === version) return { kind: 'warning', latest: newer ? notice.latest : null, warning: notice.warning };
+  if (newer) return { kind: 'update', latest: notice.latest, warning: null };
+  return null;
+}
+
+// Hook errors since someone last looked at them with `carwash doctor`.
+// Install counts as looking, so errors from before an update do not nag.
+export function unseenErrors(env = process.env) {
+  try {
+    const logged = statSync(errorLogPath(env)).mtimeMs;
+    let seen = 0;
+    try {
+      seen = statSync(errorsSeenPath(env)).mtimeMs;
+    } catch {
+      // never looked
+    }
+    return logged > seen;
+  } catch {
+    return false;
+  }
+}
+
+// One line for under the meter, or null: the author's warning first, then
+// hook errors, then a plain "newer version".
+export function statusNotice(version, env = process.env) {
+  const notice = noticeFor(readNotice(env), version, env);
+  if (notice?.kind === 'warning') return `⚠ Carwash: ${notice.warning} · to update: ${UPDATE_COMMAND}`;
+  if (unseenErrors(env)) return `Carwash hit an error · details: ${DOCTOR_COMMAND}`;
+  if (notice?.kind === 'update') return `Carwash ${notice.latest} is out (you have ${version}) · ${UPDATE_COMMAND}`;
+  return null;
+}
+
+// Said once as a session starts, when there is something to say.
+export function startNotice(version, env = process.env) {
+  const notice = noticeFor(readNotice(env), version, env);
+  if (!notice) return null;
+  if (notice.kind === 'warning') return `Carwash ${version}: ${notice.warning} To update: ${UPDATE_COMMAND}`;
+  return `Carwash ${notice.latest} is out (you have ${version}). To update: ${UPDATE_COMMAND}`;
+}
+
+// Which version this is, for /wash help, with what the last check found.
+export function versionLine(version, env = process.env) {
+  const notice = noticeFor(readNotice(env), version, env);
+  let line = `Carwash ${version}.`;
+  if (notice?.kind === 'warning') line += ` ${notice.warning} To update: ${UPDATE_COMMAND}`;
+  else if (notice?.kind === 'update') line += ` ${notice.latest} is out. To update: ${UPDATE_COMMAND}`;
+  return `${line} Something not working? Run in a terminal: ${DOCTOR_COMMAND}`;
+}

package/src/paths.mjs

@@ -35,6 +35,14 @@ export const shareIdPath = (env = process.env) => join(carwashHome(env), 'share-
 
 export const errorLogPath = (env = process.env) => join(carwashHome(env), 'errors.log');
 
+// Touched when someone has looked at the errors (doctor) or just installed, so
+// the status line only mentions errors logged after that.
+export const errorsSeenPath = (env = process.env) => join(carwashHome(env), 'errors-seen');
+
+// What the last daily check found on npm: the newest version and any warning
+// the author put on this one.
+export const noticePath = (env = process.env) => join(carwashHome(env), 'notice.json');
+
 // Present once the first-run welcome has been shown.
 export const welcomedPath = (env = process.env) => join(carwashHome(env), 'welcomed');
 

package/src/statusline/run.mjs

@@ -1,5 +1,7 @@
 import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
+import { packageVersion } from '../install/install.mjs';
+import { statusNotice } from '../install/notice.mjs';
 import { installRecordPath } from '../paths.mjs';
 import { render } from './render.mjs';
 import { washState } from './state.mjs';
@@ -102,6 +104,22 @@ function wrappedCommand(env) {
   }
 }
 
+// A line under the meter when there is news: the author's warning about this
+// version, hook errors since doctor was last run, or a newer version. Cut to
+// the window, since a wrapped line would push the meter around.
+export function withNotice(text, env = process.env, version = packageVersion()) {
+  let notice = null;
+  try {
+    notice = statusNotice(version, env);
+  } catch {
+    // no news is fine
+  }
+  if (!notice) return text;
+  const columns = availableColumns(env);
+  if (visibleWidth(notice) > columns) notice = `${[...notice].slice(0, Math.max(1, columns - 1)).join('')}…`;
+  return text ? `${text}\n${notice}` : notice;
+}
+
 // Entry point for `carwash statusline`. Must never fail loudly: a broken
 // status line is worse than a missing meter, and the user's own status line
 // has to keep working whatever happens to ours.
@@ -126,7 +144,7 @@ export async function statusline({ input, env = process.env, platform = process.
     } catch {
       // Without it the meter still renders, minus any word about a brief.
     }
-    return compose(theirs, payload, { env, platform, state });
+    return withNotice(compose(theirs, payload, { env, platform, state }), env);
   } catch {
     return (theirs ?? '').replace(/\s+$/, '');
   }

package/src/wash/brief.mjs

@@ -127,7 +127,7 @@ const LEVEL_NOTES = {
 
 // /wash help. `used` is this session's reading, when known, so each level can
 // show the most tokens its brief may take here.
-export function helpMessage(used) {
+export function helpMessage(used, footer = null) {
   const row = (args, note) => `  /wash ${args.padEnd(16)}${note}`;
   const level = (name) => {
     const cap = capFor(name, used);
@@ -144,6 +144,7 @@ export function helpMessage(used) {
     '',
     "The status line shows how many tokens this conversation is using, and the bar shows how close that is to the model's limit.",
     'Writing a brief is an ordinary Claude reply, so it uses tokens. help, discard and load do not.',
+    ...(footer ? ['', footer] : []),
   ].join('\n');
 }
 

package/src/wash/hooks.mjs

@@ -1,4 +1,6 @@
 import { existsSync, writeFileSync } from 'node:fs';
+import { packageVersion } from '../install/install.mjs';
+import { startNotice, versionLine } from '../install/notice.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';
@@ -18,6 +20,8 @@ import { AUTO_LOAD_MS, addRecord, claim, findRecords, purge, readyRecords, remov
 //                        save it.
 //   SessionStart         A session began. If a brief is meant for it, hand the
 //                        brief over. The first one after install says hello.
+//                        It also starts the daily update check, in the
+//                        background, and passes on what the last one found.
 //
 // Each handler returns the JSON to print for Claude Code, or null to stay out
 // of the way. None of them ever clears, restarts, or runs anything.
@@ -55,7 +59,7 @@ function onExpansion(payload, 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 === 'help') return block(helpMessage(loadUsage(ctx.env, payload.session_id)?.used ?? null));
+  if (verb === 'help') return block(helpMessage(loadUsage(ctx.env, payload.session_id)?.used ?? null, versionLine(ctx.version, ctx.env)));
   return block(`/wash does not know "${verb}". ${USAGE}`);
 }
 
@@ -217,7 +221,13 @@ function onSessionStart(payload, ctx) {
   if (payload.source !== 'startup' && payload.source !== 'clear') return null;
   if (unattended(ctx.env)) return null;
   // The welcome waits for a start that has nothing else to say.
-  return briefAtStart(payload, ctx) ?? welcome(ctx);
+  const result = briefAtStart(payload, ctx) ?? welcome(ctx);
+  quietly(ctx, () => ctx.checkUpdates?.());
+  let notice = null;
+  quietly(ctx, () => (notice = startNotice(ctx.version, ctx.env)));
+  if (!notice) return result;
+  if (!result) return { systemMessage: notice };
+  return { ...result, systemMessage: result.systemMessage ? `${result.systemMessage}\n\n${notice}` : notice };
 }
 
 function briefAtStart(payload, ctx) {
@@ -265,7 +275,10 @@ function briefAtStart(payload, ctx) {
 // --- entry point -----------------------------------------------------------
 
 // Handle one hook call. `input` is the JSON Claude Code sends on stdin.
-export function runHook({ input, env = process.env, platform = process.platform, now = Date.now(), me, running, onError } = {}) {
+//
+// `checkUpdates` starts the daily update check. Only the real command passes
+// it, so tests never go online.
+export function runHook({ input, env = process.env, platform = process.platform, now = Date.now(), me, running, onError, checkUpdates, version = packageVersion() } = {}) {
   let payload;
   try {
     payload = JSON.parse(input);
@@ -279,6 +292,8 @@ export function runHook({ input, env = process.env, platform = process.platform,
     me: me ?? currentProcess(env, platform),
     isRunning: running ?? ((owner) => isRunning(owner, platform)),
     onError,
+    checkUpdates,
+    version,
   };
   switch (payload.hook_event_name) {
     case 'UserPromptExpansion':