@williamthorsen/nmr 0.36.0 → 0.38.0

package/agents/README.md

@@ -11,7 +11,7 @@ A line earns a place in it only if both hold:
 1. **It is absent from nmr's own output.** Bare `nmr` already prints the flags, every command, and the shell command each resolves to; failing checks already name their own fix. Repeating any of that costs launch tokens to say something the agent will be told anyway, at the moment it matters.
 2. **The obvious action goes wrong without it.** Guidance that prevents a silent mistake earns its place; guidance that prevents a mistake the next error message would diagnose does not.
 
-Everything else belongs in `packages/nmr/README.md`, reachable on demand at `node_modules/@williamthorsen/nmr/README.md`, with a pointer from the cheatsheet naming the topic so an agent knows to look. When adding a feature, document it there and extend that pointer rather than the cheatsheet.
+Everything else belongs in the topic document under `packages/nmr/docs/` that covers it, reachable on demand at `node_modules/@williamthorsen/nmr/docs/`, with a pointer from the cheatsheet naming the topic and its document so an agent knows where to look. When adding a feature, document it there and extend that pointer rather than the cheatsheet.
 
 ## Constraints on rulebook bodies
 

package/agents/guidance/rulebooks/nmr.md

@@ -10,8 +10,8 @@ delivery: ambient
 - Scope follows cwd, and bare `nmr` lists both registries: from the repo root a command covers root files and every workspace; from inside a package, that package alone. `nmr -F <pkg> <command>` targets one package from anywhere; `nmr root:<command>` targets root files alone, which isolates a failure to root code.
 - Never `npx nmr`: inside a git worktree it can resolve a different nmr from outside the tree. Fall back to `pnpm exec nmr`.
 - `nmr ci` runs what a code-quality workflow runs (build, then strict checks) and not the dependency audit, which belongs to a workflow of its own; `nmr prepush` runs the audit first, then `ci`, so a vulnerability stops the run before the long gate. Neither installs or binds a git hook.
-- A check that already passed on the current working tree skips, printing `⏭️ <scope>: <command>: passed …` and, where the recalled run left one, `— replayed: <excerpt>` of what that run concluded. Any edit, addition, or deletion re-runs it, so read the replayed excerpt rather than paying for the answer again: never pass `--no-cache` to get a "real" run, which costs the command's full runtime to reach the same answer. Its one use is a file rather than an exit status -- a skipped command writes none, so a fresh `coverage/` needs `nmr --no-cache test:coverage`. A composite replays its constituents' excerpts, each attributed as `<scope>: <command>: <excerpt>` and cut at the line's ceiling where there are too many to fit. A skip carrying no excerpt is one whose run wrote to a terminal, or one whose constituents recorded none.
+- A check that already passed on the current working tree skips, printing `SKIP <scope>: <command>: passed …` and, where the recalled run left one, `— replayed: <excerpt>` of what that run concluded. Any edit, addition, or deletion re-runs it, so read the replayed excerpt rather than paying for the answer again: never pass `--no-cache` to get a "real" run, which costs the command's full runtime to reach the same answer. Its one use is a file rather than an exit status -- a skipped command writes none, so a fresh `coverage/` needs `nmr --no-cache test:coverage`. A composite replays its constituents' excerpts, each attributed as `<scope>: <command>: <excerpt>` and cut at the line's ceiling where there are too many to fit. A skip carrying no excerpt is one whose run wrote to a terminal, or one whose constituents recorded none.
 - `nmr --log <command>` prints the whole run behind that excerpt -- up to 256 KiB, led by when it was recorded, how long it ran, and the command string that produced it -- so output you need in full is a recording to read rather than a run to pay for again. It runs nothing, and it is held to the tree rather than to the terminal: a recording a piped run made prints for a reader at one. A composite prints its constituents' excerpts, so the transcript of one of them is `nmr -F <pkg> --log <command>` or that constituent's own name. Nothing to show is said on one line and exits non-zero, naming which it is.
-- Every command nmr runs reports one line -- `✅ <scope>: <command>: passed in 12.4s`, `❌ … failed in 1.2s (exit 1)`, `⏭️ … passed 4m ago on this tree`, or `⛔ … skipped, the override is empty` -- and a composite reports alongside every command it expands into. The lines print in every verbosity, so `-q` is the low-noise way to run rather than a silent one: it withholds the output of the commands nmr runs and keeps nmr's own verdicts, which is how a pass, a cached skip, and a `""`/`":"` override stay distinguishable. Expect a run to be quiet already without the flag: nmr recognizes a known agent harness in the environment and takes quiet from that, as it does from `NMR_COMMAND_VERBOSITY` or the repo's `output.commandVerbosity`. A command whose output you need in full is one to run with `NMR_COMMAND_VERBOSITY=full`, which outranks both.
-- Every test file lives under a `__tests__` directory and names its isolation tier last: `<subject>[.<aspect>].<tier>.test.ts`, where any earlier segment is free-form documentation. A tier is the furthest thing the test reaches -- `tool` (a program the environment supplies), `localhost` (a service on this machine), `remote` (a machine that isn't this one), or `unit`, the residual claiming everything else. A file outside `__tests__`, or one whose tier segment is missing or misspelt, fails the test run in a repo that declares nmr's exported conventions check, which reports both. In a repo that has not, neither fails anything -- the first is collected by nothing and the second runs under `unit` -- and `rdy run --packages` reports the misspelt tier alone.
-- The rest is in `node_modules/@williamthorsen/nmr/README.md`: pre/post hooks (every `nmr X` auto-wraps as `nmr X:pre && nmr X && nmr X:post`), script overrides and their `""`/`":"` skip values, `nmr upgrade` ceilings (report-only until `nmr upgrade --write`), the `nmr-compile` build (there is no repo-local build script), the test tiers' timeout budgets and the `tiers` seam that raises one, which script reaches which tier, and the check-result cache's key, the retention key a replayed excerpt is additionally held to, the retention ceiling `--log` prints within, its `checkCache` config, and every condition that disables it.
+- Every command nmr runs reports one line -- `PASS <scope>: <command>: passed in 12.4s`, `FAIL … failed in 1.2s (exit 1)`, `SKIP … passed 4m ago on this tree`, or `NOOP … skipped, the override is empty` -- and a composite reports alongside every command it expands into. Those are the words a pipe and a CI log get; a terminal gets ✅, ❌, ⏩, and ⚪ in their place, and `--output-style rich` or `NMR_OUTPUT_STYLE=rich` forces the emoji on any stream. The lines print in every verbosity, so `-q` is the low-noise way to run rather than a silent one: it withholds the output of the commands nmr runs and keeps nmr's own verdicts, which is how a pass, a cached skip, and a `""`/`":"` override stay distinguishable. Expect a run to be quiet already without the flag: nmr recognizes a known agent harness in the environment and takes quiet from that, as it does from `NMR_COMMAND_VERBOSITY` or the repo's `output.commandVerbosity`. A command whose output you need in full is one to run with `NMR_COMMAND_VERBOSITY=full`, which outranks both.
+- Every test file lives under a `__tests__` directory and names its isolation tier last: `<subject>[.<aspect>].<tier>.test.ts`, where any earlier segment is free-form documentation. A tier is the furthest thing the test reaches -- `tool` (a program the environment supplies), `localhost` (a service on this machine), `remote` (a machine that isn't this one), or `unit`, the residual claiming everything else. A file outside `__tests__`, or one whose tier segment is missing or misspelt, fails the test run in a repo that declares nmr's exported conventions check, which reports both. In a repo that has not, neither fails anything -- the first is collected by nothing and the second runs under `unit` -- and `rdy run --packages` reports both and warns that the check is missing.
+- The rest is in `node_modules/@williamthorsen/nmr/docs/`: `scripts.md` for pre/post hooks (every `nmr X` auto-wraps as `nmr X:pre && nmr X && nmr X:post`) and script overrides and their `""`/`":"` skip values; `upgrades.md` for `nmr upgrade` ceilings (report-only until `nmr upgrade --write`); `utilities.md` for the `nmr-compile` build (there is no repo-local build script); `vitest.md` for the test tiers' timeout budgets, the `tiers` seam that raises one, and which script reaches which tier; and `check-cache.md` for the check-result cache's key, the retention key a replayed excerpt is additionally held to, the retention ceiling `--log` prints within, its `checkCache` config, and every condition that disables it.

package/dist/esm/check-cache.d.ts

@@ -1,4 +1,5 @@
 import type { Writable } from 'node:stream';
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 import type { OutputChannels } from './runner.js';
 import type { CheckCacheConfig, NmrConfig } from './types.js';
 /** A recorded pass: what ran, on which tree, and what it cost. */
@@ -159,7 +160,7 @@ export declare function findStaleBuildOutput(earlier: Record<string, string>, la
  * command rather than a flag to nmr. Passing it on unchanged is the honest thing to do with an argument, so
  * the warning is all that separates this from a silently un-bypassed run.
  */
-export declare function formatMisplacedNoCacheWarning(command: string): string;
+export declare function formatMisplacedNoCacheWarning(command: string, style: OutputStyle): string;
 /**
  * Reports whether a command's passes are recorded at all, which is what separates a command with no recording
  * from one that could never have had one.

package/dist/esm/check-cache.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { readFileSync, realpathSync } from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
-import { hashWorkingTree, readCacheEntry, readHeadSha, readJsonCacheEntry, removeCacheDir, removeCacheEntry, resolveCacheEntryPath, writeCacheEntry, } from '@williamthorsen/nmr-core';
+import { hashWorkingTree, readCacheEntry, readHeadSha, readJsonCacheEntry, removeCacheDir, removeCacheEntry, resolveCacheEntryPath, STATUS_GLYPHS, writeCacheEntry, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { hasBuildOutput, readBuildDigest } from "./commands/build-output.js";
 import { loadWorkspaceConfig } from "./config.js";
@@ -107,9 +107,9 @@ export function findStaleBuildOutput(earlier, later) {
     const names = [...new Set([...Object.keys(earlier), ...Object.keys(later)])].toSorted();
     return names.find((name) => earlier[name] !== later[name]);
 }
-export function formatMisplacedNoCacheWarning(command) {
-    return (`⚠️ --no-cache after the command name is passed to \`${command}\`, not read by nmr. ` +
-        `Did you mean \`nmr --no-cache ${command}\`?`);
+export function formatMisplacedNoCacheWarning(command, style) {
+    return (`${STATUS_GLYPHS[style].warning.text} --no-cache after the command name is passed to \`${command}\`, ` +
+        `not read by nmr. Did you mean \`nmr --no-cache ${command}\`?`);
 }
 export function isCacheableCommand(checkCache, command) {
     return !isHookName(command) && checkCache?.enabled !== false && resolveCacheableCommands(checkCache).has(command);

package/dist/esm/cli-build.js

@@ -2,10 +2,13 @@ import { reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { buildPackage } from "./commands/build.js";
 import { loadWorkspaceConfig } from "./config.js";
+import { resolveBinStyles } from "./resolveBinStyles.js";
 try {
+    const { stdout } = resolveBinStyles();
     const packageDir = process.cwd();
     const { build } = await loadWorkspaceConfig(packageDir);
     await buildPackage(packageDir, {
+        style: stdout,
         ...(build?.extraIgnorePatterns !== undefined && { extraIgnorePatterns: build.extraIgnorePatterns }),
     });
 }

package/dist/esm/cli-clean.js

@@ -1,8 +1,10 @@
+import process from 'node:process';
 import { reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { runClean } from "./commands/clean.js";
+import { resolveBinStyles } from "./resolveBinStyles.js";
 try {
-    await runClean(process.cwd());
+    await runClean(process.cwd(), resolveBinStyles().stdout);
 }
 catch (error) {
     reportError(describeError(error));

package/dist/esm/cli-ensure-prepublish-hooks.js

@@ -1,6 +1,7 @@
 import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { DEFAULT_HOOK, ensurePrepublishHooks, reportPrepublishHooks } from "./commands/ensure-prepublish-hooks.js";
+import { resolveBinStyles } from "./resolveBinStyles.js";
 import { findMonorepoRoot } from "./workspace.js";
 const flagSchema = {
     fix: { long: '--fix', type: 'boolean' },
@@ -9,10 +10,11 @@ const flagSchema = {
 };
 const { fix, dryRun, command } = parseArgsOrExit(process.argv.slice(2), flagSchema).flags;
 try {
+    const { stdout } = resolveBinStyles();
     const monorepoRoot = findMonorepoRoot();
     const options = command ? { fix, dryRun, command } : { fix, dryRun };
     const result = ensurePrepublishHooks(monorepoRoot, options);
-    reportPrepublishHooks(result, command ?? DEFAULT_HOOK);
+    reportPrepublishHooks(result, command ?? DEFAULT_HOOK, stdout);
     if (result.hasFailures) {
         process.exitCode = 1;
     }

package/dist/esm/cli-report-catalog.js

@@ -2,8 +2,9 @@ import process from 'node:process';
 import { reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { reportCatalog } from "./commands/report-catalog.js";
+import { resolveBinStyles } from "./resolveBinStyles.js";
 try {
-    reportCatalog(process.cwd());
+    reportCatalog(process.cwd(), resolveBinStyles().stderr);
 }
 catch (error) {
     reportError(describeError(error));

package/dist/esm/cli-report-overrides.js

@@ -1,10 +1,11 @@
 import { reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { reportOverrides } from "./commands/report-overrides.js";
+import { resolveBinStyles } from "./resolveBinStyles.js";
 import { findMonorepoRoot } from "./workspace.js";
 try {
     const monorepoRoot = findMonorepoRoot();
-    reportOverrides(monorepoRoot);
+    reportOverrides(monorepoRoot, resolveBinStyles().stderr);
 }
 catch (error) {
     reportError(describeError(error));

package/dist/esm/commands/build.d.ts

@@ -1,3 +1,4 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 import { type BuildOptions } from './build-output.js';
 /**
  * The toolchain a build's emit comes from: the resolved compiler and the nmr running it. Both join the build
@@ -7,6 +8,10 @@ export interface BuildToolchain {
     compilerVersion: string;
     fingerprint: string;
 }
+/** What a build needs beyond its sources: the options shaping the emit, and the style it reports in. */
+export interface BuildPackageOptions extends BuildOptions {
+    style: OutputStyle;
+}
 /**
  * Compiles a package's `src` tree to `dist/esm` with the TypeScript compiler API, emitting `.js` and
  * `.d.ts` from two programs and rewriting relative `.ts` specifiers and tsconfig `paths` aliases to
@@ -17,7 +22,7 @@ export interface BuildToolchain {
  * current inputs rather than an accumulation of every build that ever ran. Assets belong outside it, or in a
  * `build:post` hook, which runs after the output is published.
  */
-export declare function buildPackage(packageDir: string, options?: BuildOptions): Promise<void>;
+export declare function buildPackage(packageDir: string, options: BuildPackageOptions): Promise<void>;
 /**
  * Produces a digest of the given files (paths and contents), the emit config, and the toolchain.
  * The file list is sorted so the digest is order-invariant, and each path is folded in so renames are detected.

package/dist/esm/commands/build.js

@@ -2,19 +2,18 @@ import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { readFile, rename, rm } from 'node:fs/promises';
 import path from 'node:path';
-import { readCacheEntry, writeCacheEntry } from '@williamthorsen/nmr-core';
+import { formatGlyphLine, readCacheEntry, STATUS_GLYPHS, writeCacheEntry, } from '@williamthorsen/nmr-core';
 import { glob } from 'glob';
 import * as ts from 'typescript';
+import { NMR_GLYPHS } from "../glyphs.js";
 import { resolveConfigPath } from "../helpers/config-path.js";
 import { DEFAULT_ENTRY_GLOBS, DEFAULT_IGNORE_PATTERNS, DEFAULT_OUTDIR, hasExpectedBuildOutput, resolveBuildCachePath, resolveScratchDirs, resolveToolchainFingerprint, } from "./build-output.js";
-const PACKAGE_ICON = '📦';
-const SKIPPED_ICON = '⏭️';
 const SOURCE_ROOT = 'src';
 const MINIMUM_TYPESCRIPT_MAJOR = 5;
 const MINIMUM_TYPESCRIPT_MINOR = 7;
 const TS_EXTENSION = '.ts';
 const JS_EXTENSION = '.js';
-export async function buildPackage(packageDir, options = {}) {
+export async function buildPackage(packageDir, options) {
     assertSupportedTypeScript();
     const cachePath = resolveBuildCachePath(packageDir);
     const outdir = options.outdir ?? DEFAULT_OUTDIR;
@@ -34,14 +33,14 @@ export async function buildPackage(packageDir, options = {}) {
         compilerVersion: ts.version,
         fingerprint: await resolveToolchainFingerprint(packageDir),
     };
-    const { changed, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, toolchain, cachePath, hasExpectedBuildOutput(packageDir, outdir, entryPoints));
+    const { changed, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, toolchain, cachePath, hasExpectedBuildOutput(packageDir, outdir, entryPoints), options.style);
     if (!changed) {
         await discardScratchDirs(resolveScratchDirs(emitDir));
         return;
     }
     const emittedFileCount = await emitPackage(packageDir, entryPoints, outdir);
     await writeCacheEntry(cachePath, currentHash);
-    console.info(`${PACKAGE_ICON} ${path.basename(packageDir)}: ${describeEmit(emittedFileCount, outdir)}`);
+    console.info(formatGlyphLine(NMR_GLYPHS, options.style, 'package', `${path.basename(packageDir)}: ${describeEmit(emittedFileCount, outdir)}`));
 }
 export async function computeBuildHash(packageDir, files, emitConfig, toolchain) {
     const hash = createHash('sha256');
@@ -275,19 +274,19 @@ function getModuleSpecifier(node) {
     }
     return undefined;
 }
-async function detectBuildChanges(packageDir, files, emitConfig, toolchain, cachePath, outputPresent) {
+async function detectBuildChanges(packageDir, files, emitConfig, toolchain, cachePath, outputPresent, style) {
     const packageName = path.basename(packageDir);
     const previousHash = await readCacheEntry(cachePath);
     const currentHash = await computeBuildHash(packageDir, files, emitConfig, toolchain);
     if (previousHash === currentHash) {
         if (outputPresent) {
-            console.info(`${SKIPPED_ICON} ${packageName}: No changes detected. Skipping build.`);
+            console.info(`${STATUS_GLYPHS[style].skipped.text} ${packageName}: No changes detected. Skipping build.`);
             return { changed: false, currentHash };
         }
-        console.info(`${PACKAGE_ICON} ${packageName}: Build output is missing. Rebuilding.`);
+        console.info(formatGlyphLine(NMR_GLYPHS, style, 'package', `${packageName}: Build output is missing. Rebuilding.`));
         return { changed: true, currentHash };
     }
-    console.info(`${PACKAGE_ICON} ${packageName}: Changes detected.`);
+    console.info(formatGlyphLine(NMR_GLYPHS, style, 'package', `${packageName}: Changes detected.`));
     return { changed: true, currentHash };
 }
 function assertSupportedTypeScript() {

package/dist/esm/commands/clean.d.ts

@@ -1,8 +1,9 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 /**
  * Removes a package's build output and the build-cache entry that describes it, so no state survives to
  * make the next build skip. Removal is idempotent: an already-clean package is a silent no-op.
  */
-export declare function cleanPackage(packageDir: string): Promise<void>;
+export declare function cleanPackage(packageDir: string, style: OutputStyle): Promise<void>;
 /**
  * Cleans the package containing `cwd`, or every workspace package when run from the monorepo root.
  *
@@ -14,4 +15,4 @@ export declare function cleanPackage(packageDir: string): Promise<void>;
  * a `rimraf` in nmr's dependency tree would be unreachable — while nmr's own bins are linked into the
  * consumer's `node_modules/.bin`, nmr being a direct dependency.
  */
-export declare function runClean(cwd?: string): Promise<void>;
+export declare function runClean(cwd: string, style: OutputStyle): Promise<void>;

package/dist/esm/commands/clean.js

@@ -1,52 +1,53 @@
 import { rm } from 'node:fs/promises';
 import path from 'node:path';
+import { formatGlyphLine } from '@williamthorsen/nmr-core';
 import { removeCheckCache } from "../check-cache.js";
 import { loadRootConfig } from "../config.js";
 import { findContainingPackageDir } from "../context.js";
+import { NMR_GLYPHS } from "../glyphs.js";
 import { reportClosing } from "../helpers/reportClosing.js";
 import { applyDevBin, buildWorkspaceRegistry, resolveScript } from "../resolver.js";
 import { resolveChannel, runCommand } from "../runner.js";
 import { renderChain } from "../steps.js";
 import { findMonorepoRoot, getWorkspacePackageDirs } from "../workspace.js";
 import { resolveBuildCachePath } from "./build-output.js";
-const CLEAN_ICON = '🧹';
 const CLEAN_COMMAND = 'clean';
 const BUILT_IN_CLEAN = 'nmr-clean';
 const OUTPUT_ROOT = 'dist';
-export async function cleanPackage(packageDir) {
+export async function cleanPackage(packageDir, style) {
     await rm(path.resolve(packageDir, OUTPUT_ROOT), { recursive: true, force: true });
     await rm(resolveBuildCachePath(packageDir), { force: true });
-    console.info(`${CLEAN_ICON} ${path.basename(packageDir)}: Removed build output and cache.`);
+    console.info(formatGlyphLine(NMR_GLYPHS, style, 'clean', `${path.basename(packageDir)}: Removed build output and cache.`));
 }
-export async function runClean(cwd = process.cwd()) {
+export async function runClean(cwd, style) {
     let monorepoRoot;
     try {
         monorepoRoot = findMonorepoRoot(cwd);
     }
     catch {
-        await clearCheckCache(cwd);
-        await cleanPackage(cwd);
+        await clearCheckCache(cwd, style);
+        await cleanPackage(cwd, style);
         return;
     }
-    await clearCheckCache(monorepoRoot);
+    await clearCheckCache(monorepoRoot, style);
     const workspacePackageDirs = getWorkspacePackageDirs(monorepoRoot);
     const packageDir = findContainingPackageDir(cwd, workspacePackageDirs);
     if (packageDir !== undefined) {
-        await cleanPackage(packageDir);
+        await cleanPackage(packageDir, style);
         return;
     }
-    await sweepWorkspace(monorepoRoot, workspacePackageDirs);
+    await sweepWorkspace(monorepoRoot, workspacePackageDirs, style);
 }
-async function clearCheckCache(scopeDir) {
+async function clearCheckCache(scopeDir, style) {
     await removeCheckCache(scopeDir);
-    console.info(`${CLEAN_ICON} Removed all recorded check results.`);
+    console.info(formatGlyphLine(NMR_GLYPHS, style, 'clean', 'Removed all recorded check results.'));
 }
 function describeSweep(cleaned, skipped) {
     const packages = cleaned === 1 ? '1 package' : `${cleaned} packages`;
     const skipClause = skipped === 0 ? '' : `, skipping ${skipped} with an empty clean override`;
     return `Cleaned ${packages}${skipClause}.`;
 }
-async function sweepWorkspace(monorepoRoot, workspacePackageDirs) {
+async function sweepWorkspace(monorepoRoot, workspacePackageDirs, style) {
     const config = await loadRootConfig(monorepoRoot);
     const registry = buildWorkspaceRegistry(config);
     let cleaned = 0;
@@ -59,7 +60,7 @@ async function sweepWorkspace(monorepoRoot, workspacePackageDirs) {
             continue;
         }
         if (resolvedCommand === BUILT_IN_CLEAN) {
-            await cleanPackage(packageDir);
+            await cleanPackage(packageDir, style);
             cleaned++;
             continue;
         }
@@ -72,5 +73,5 @@ async function sweepWorkspace(monorepoRoot, workspacePackageDirs) {
         }
         cleaned++;
     }
-    reportClosing(`${CLEAN_ICON} ${describeSweep(cleaned, skipped)}`);
+    reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'clean', describeSweep(cleaned, skipped)));
 }

package/dist/esm/commands/ensure-prepublish-hooks.d.ts

@@ -1,3 +1,4 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 export interface PackageHookStatus {
     packageName: string;
     packageDir: string;
@@ -23,7 +24,7 @@ export declare function ensurePrepublishHooks(monorepoRoot: string, options: {
  * Reports one line per publishable package and closes with what the run came to. Private packages appear in
  * neither: they publish nothing, so a `prepublishOnly` is not theirs to carry.
  *
- * Every line goes to stdout, the `✗` included, and the exit code is what carries a failure. A report split
+ * Every line goes to stdout, a failure's included, and the exit code is what carries a failure. A report split
  * across two streams leaves no reader holding the whole list.
  */
-export declare function reportPrepublishHooks(result: EnsurePrepublishHooksResult, hookCommand: string): void;
+export declare function reportPrepublishHooks(result: EnsurePrepublishHooksResult, hookCommand: string, style: OutputStyle): void;

package/dist/esm/commands/ensure-prepublish-hooks.js

@@ -1,5 +1,6 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
+import { STATUS_GLYPHS } from '@williamthorsen/nmr-core';
 import { readPackageJson } from "../helpers/package-json.js";
 import { reportClosing } from "../helpers/reportClosing.js";
 import { isObject } from "../helpers/type-guards.js";
@@ -60,14 +61,14 @@ export function ensurePrepublishHooks(monorepoRoot, options) {
     const hasFailures = packages.some((p) => p.action === 'missing');
     return { packages, hasFailures };
 }
-export function reportPrepublishHooks(result, hookCommand) {
+export function reportPrepublishHooks(result, hookCommand, style) {
     const publishable = result.packages.filter((pkg) => !pkg.isPrivate);
     if (publishable.length === 0) {
         console.info('No publishable packages found.');
         return;
     }
     for (const pkg of publishable) {
-        console.info(renderHookStatus(pkg, hookCommand));
+        console.info(renderHookStatus(pkg, hookCommand, style));
     }
     reportClosing(describeHookRun(publishable));
 }
@@ -102,14 +103,15 @@ function describeHookRun(publishable) {
     }
     return `${packages} ${publishable.length === 1 ? 'has' : 'have'} prepublishOnly.`;
 }
-function renderHookStatus(pkg, hookCommand) {
+function renderHookStatus(pkg, hookCommand, style) {
+    const statuses = STATUS_GLYPHS[style];
     switch (pkg.action) {
         case 'ok':
-            return `✓ ${pkg.packageName}: prepublishOnly = "${pkg.prepublishOnly}"`;
+            return `${statuses.passed.text} ${pkg.packageName}: prepublishOnly = "${pkg.prepublishOnly}"`;
         case 'missing':
-            return `✗ ${pkg.packageName}: missing prepublishOnly`;
+            return `${statuses.failed.text} ${pkg.packageName}: missing prepublishOnly`;
         case 'fixed':
-            return `✓ ${pkg.packageName}: added prepublishOnly = "${hookCommand}"`;
+            return `${statuses.passed.text} ${pkg.packageName}: added prepublishOnly = "${hookCommand}"`;
         case 'would-fix':
             return `~ ${pkg.packageName}: would add prepublishOnly = "${hookCommand}"`;
     }

package/dist/esm/commands/report-catalog.d.ts

@@ -1,3 +1,4 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 /**
  * Reports the catalogued dependencies a package-scoped upgrade pass cannot see.
  *
@@ -8,4 +9,4 @@
  *
  * Runs ahead of the report produced by the workspace `upgrade` script.
  */
-export declare function reportCatalog(cwd: string): void;
+export declare function reportCatalog(cwd: string, style: OutputStyle): void;

package/dist/esm/commands/report-catalog.js

@@ -1,10 +1,11 @@
+import { formatGlyphLine } from '@williamthorsen/nmr-core';
 import { findContainingPackageDir } from "../context.js";
+import { NMR_GLYPHS } from "../glyphs.js";
 import { DEPENDENCY_FIELDS, readPackageJson } from "../helpers/package-json.js";
 import { reportClosing } from "../helpers/reportClosing.js";
 import { findMonorepoRoot, getWorkspacePackageDirs } from "../workspace.js";
-const CATALOG_ICON = '📚';
 const CATALOG_PROTOCOL = 'catalog:';
-export function reportCatalog(cwd) {
+export function reportCatalog(cwd, style) {
     const monorepoRoot = findMonorepoRoot(cwd);
     const packageDir = findContainingPackageDir(cwd, getWorkspacePackageDirs(monorepoRoot));
     if (packageDir === undefined) {
@@ -14,11 +15,11 @@ export function reportCatalog(cwd) {
     if (dependencies.length === 0) {
         return;
     }
-    console.warn(`${CATALOG_ICON} WARN: A package-scoped upgrade does not read the catalogs these come from:`);
+    console.warn(formatGlyphLine(NMR_GLYPHS, style, 'catalog', 'WARN: A package-scoped upgrade does not read the catalogs these come from:'));
     for (const { name, specifier } of dependencies) {
         console.warn(`- ${name} → ${specifier}`);
     }
-    reportClosing(`${CATALOG_ICON} ${describeCatalog(dependencies.length, monorepoRoot)}`, console.warn);
+    reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'catalog', describeCatalog(dependencies.length, monorepoRoot)), console.warn);
 }
 function describeCatalog(count, monorepoRoot) {
     const subject = count === 1 ? '1 catalogued dependency went' : `${count} catalogued dependencies went`;

package/dist/esm/commands/report-overrides.d.ts

@@ -1,7 +1,8 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 /**
  * Reports the pnpm dependency overrides declared in the monorepo root's `pnpm-workspace.yaml`, and rejects a
  * `pnpm.overrides` block left behind in the root `package.json`.
  *
  * Runs ahead of the report produced by the root `upgrade` script.
  */
-export declare function reportOverrides(monorepoRoot: string): void;
+export declare function reportOverrides(monorepoRoot: string, style: OutputStyle): void;

package/dist/esm/commands/report-overrides.js

@@ -1,16 +1,17 @@
+import { formatGlyphLine } from '@williamthorsen/nmr-core';
+import { NMR_GLYPHS } from "../glyphs.js";
 import { getPnpmOverrides, readPackageJson } from "../helpers/package-json.js";
 import { reportClosing } from "../helpers/reportClosing.js";
 import { UserError } from "../UserError.js";
 import { readWorkspaceOverrides } from "../workspace.js";
-const OVERRIDES_ICON = '🔒';
-export function reportOverrides(monorepoRoot) {
+export function reportOverrides(monorepoRoot, style) {
     const declared = listEntries(readWorkspaceOverrides(monorepoRoot));
     if (declared.length > 0) {
-        console.warn(`${OVERRIDES_ICON} WARN: pnpm overrides are active:`);
+        console.warn(formatGlyphLine(NMR_GLYPHS, style, 'overrides', 'WARN: pnpm overrides are active:'));
         for (const [name, version] of declared) {
             console.warn(`- ${name} → ${version}`);
         }
-        reportClosing(`${OVERRIDES_ICON} ${describeOverrides(declared.length)}`, console.warn);
+        reportClosing(formatGlyphLine(NMR_GLYPHS, style, 'overrides', describeOverrides(declared.length)), console.warn);
     }
     rejectLegacyOverrides(monorepoRoot);
 }

package/dist/esm/config.js

@@ -33,7 +33,8 @@ const RECOGNIZED_KEYS = [...CONFIG_TIERS.root.honoredKeys, ...CONFIG_TIERS.works
 const RECOGNIZED_BUILD_KEYS = ['extraIgnorePatterns'];
 const RECOGNIZED_CHECK_CACHE_KEYS = ['enabled', 'excludeCommands', 'extraCommands'];
 const RECOGNIZED_OUTPUT_KEYS = ['commandVerbosity', 'extraAgentEnvVars'];
-const RECOGNIZED_STEP_KEYS = ['declinesArgs', 'run'];
+const RECOGNIZED_STEP_KEYS = ['run', 'shouldDeclineArguments'];
+const RETIRED_STEP_KEYS = new Map([['declinesArgs', 'shouldDeclineArguments']]);
 function isScriptRecord(value) {
     if (!isObject(value))
         return false;
@@ -50,8 +51,8 @@ function isScriptElement(value) {
         return true;
     if (!isObject(value) || typeof value['run'] !== 'string')
         return false;
-    const declinesArgs = value['declinesArgs'];
-    return declinesArgs === undefined || typeof declinesArgs === 'boolean';
+    const shouldDeclineArguments = value['shouldDeclineArguments'];
+    return shouldDeclineArguments === undefined || typeof shouldDeclineArguments === 'boolean';
 }
 function validateScriptField(value, fieldName, configPath) {
     if (!Object.hasOwn(value, fieldName) || value[fieldName] === undefined) {
@@ -60,7 +61,7 @@ function validateScriptField(value, fieldName, configPath) {
     const scripts = value[fieldName];
     if (!isScriptRecord(scripts)) {
         throw new UserError(`Invalid nmr config at ${configPath}: \`${fieldName}\` must be a Record<string, string | element[]>, ` +
-            'where an element is a command string or `{ run: string, declinesArgs?: boolean }`');
+            'where an element is a command string or `{ run: string, shouldDeclineArguments?: boolean }`');
     }
     assertValidElements(scripts, fieldName, configPath);
     return scripts;
@@ -71,6 +72,7 @@ function assertValidElements(scripts, fieldName, configPath) {
             continue;
         for (const spec of script) {
             if (typeof spec !== 'string') {
+                assertNoRetiredKeys(spec, RETIRED_STEP_KEYS, configPath, `${fieldName}.${command}.`);
                 assertRecognizedKeys(spec, RECOGNIZED_STEP_KEYS, configPath, `${fieldName}.${command}.`);
             }
             const element = typeof spec === 'string' ? spec : spec.run;
@@ -270,6 +272,14 @@ export async function loadWorkspaceConfig(packageDir) {
     assertTierKeys(config, CONFIG_TIERS.workspace, resolveConfigPath(packageDir));
     return config;
 }
+function assertNoRetiredKeys(value, retiredKeys, configPath, prefix) {
+    for (const key of Object.keys(value)) {
+        const replacement = retiredKeys.get(key);
+        if (replacement === undefined)
+            continue;
+        throw new UserError(`Invalid nmr config at ${configPath}: \`${prefix}${key}\` was renamed to \`${prefix}${replacement}\`.`);
+    }
+}
 function assertRecognizedKeys(value, recognizedKeys, configPath, prefix = '') {
     const unrecognized = Object.keys(value).filter((key) => !recognizedKeys.includes(key));
     if (unrecognized.length === 0) {

package/dist/esm/context.d.ts

@@ -3,6 +3,8 @@ export interface ResolvedContext {
     monorepoRoot: string;
     isRoot: boolean;
     packageDir?: string;
+    /** The workspace's package directories, resolved once here rather than swept for again by each reader. */
+    workspacePackageDirs: string[];
     config: NmrConfig;
 }
 /**

package/dist/esm/context.js

@@ -24,6 +24,7 @@ export async function resolveContext(cwd) {
         monorepoRoot,
         isRoot: packageDir === undefined,
         ...(packageDir !== undefined && { packageDir }),
+        workspacePackageDirs: workspaceDirs,
         config,
     };
 }

package/dist/esm/default-scripts.d.ts

@@ -1,6 +1,6 @@
 /**
  * One element of a composite, paired with what it does with the invocation's trailing arguments. The bare
- * string form of an element is this spec with `declinesArgs` left at its default.
+ * string form of an element is this spec with `shouldDeclineArguments` left at its default.
  */
 export interface StepSpec {
     /** A command name, optionally preceded by nmr's own flags, as it would be typed after `nmr`. */
@@ -9,7 +9,7 @@ export interface StepSpec {
      * Set where the trailing arguments cannot narrow this step's work: it is a prerequisite the narrowed steps
      * run against, or the tool it reaches would be misled by them. A declining step runs unnarrowed.
      */
-    declinesArgs?: boolean;
+    shouldDeclineArguments?: boolean;
 }
 export type ScriptValue = string | ReadonlyArray<string | StepSpec>;
 export type ScriptRegistry = Record<string, ScriptValue>;

package/dist/esm/default-scripts.js

@@ -1,6 +1,6 @@
 const GATE_PROJECTS = '--project unit --project tool';
-const TYPECHECK_STEP = { run: 'typecheck', declinesArgs: true };
-const ROOT_TYPECHECK_STEP = { run: 'root:typecheck', declinesArgs: true };
+const TYPECHECK_STEP = { run: 'typecheck', shouldDeclineArguments: true };
+const ROOT_TYPECHECK_STEP = { run: 'root:typecheck', shouldDeclineArguments: true };
 export const workspaceScripts = {
     build: ['compile'],
     check: [TYPECHECK_STEP, 'fmt:check', 'lint:check', 'test'],
@@ -32,7 +32,7 @@ export const rootScripts = {
     build: ['-R build'],
     check: [TYPECHECK_STEP, 'fmt:check', 'lint:check', 'test'],
     'check:strict': [TYPECHECK_STEP, 'fmt:check', 'lint:strict', 'test'],
-    ci: [{ run: 'build', declinesArgs: true }, 'check:strict'],
+    ci: [{ run: 'build', shouldDeclineArguments: true }, 'check:strict'],
     clean: 'nmr-clean',
     fix: ['lint', 'fmt'],
     'fix:check': ['fmt:check', 'lint:check'],
@@ -41,7 +41,7 @@ export const rootScripts = {
     lint: 'eslint --fix .',
     'lint:check': 'eslint .',
     'lint:strict': 'strict-lint',
-    prepush: [{ run: 'audit', declinesArgs: true }, 'ci'],
+    prepush: [{ run: 'audit', shouldDeclineArguments: true }, 'ci'],
     'report-overrides': 'nmr-report-overrides',
     'root:check': [ROOT_TYPECHECK_STEP, 'fmt:check', 'root:lint:check', 'root:test'],
     'root:lint': "eslint --fix --ignore-pattern 'packages/**' .",
@@ -59,6 +59,6 @@ export const rootScripts = {
     'test:tool': ['root:test:tool', '-R test:tool'],
     'test:unit': ['root:test:unit', '-R test:unit'],
     'test:watch': `vitest ${GATE_PROJECTS} --watch`,
-    typecheck: [ROOT_TYPECHECK_STEP, { run: '-R typecheck', declinesArgs: true }],
+    typecheck: [ROOT_TYPECHECK_STEP, { run: '-R typecheck', shouldDeclineArguments: true }],
     upgrade: 'nmr-report-overrides && nmr-taze --recursive',
 };

package/dist/esm/glyphs.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Glyphs that name no status; a status marker comes from nmr-core's `STATUS_GLYPHS`. A plain variant is empty
+ * where a word always follows the glyph, and a word where the glyph opens a line of its own.
+ *
+ * `noop` is a neutral circle: nothing ran because the repo asked for nothing to run, which is neither a
+ * failure nor a block.
+ */
+export declare const NMR_GLYPHS: Readonly<Record<"plain" | "rich", Readonly<Record<"overrides" | "clean" | "package" | "catalog" | "noop" | "recording", import("@williamthorsen/toolbelt.terminal/candidate").Glyph>>>>;
+export type NmrGlyphName = keyof (typeof NMR_GLYPHS)['rich'];

package/dist/esm/glyphs.js

@@ -0,0 +1,9 @@
+import { defineGlyphSet } from '@williamthorsen/nmr-core';
+export const NMR_GLYPHS = defineGlyphSet({
+    catalog: { plain: '', rich: '\u{1F4DA}' },
+    clean: { plain: '', rich: '\u{1F9F9}' },
+    noop: { plain: 'NOOP', rich: '\u{26AA}' },
+    overrides: { plain: '', rich: '\u{1F512}' },
+    package: { plain: '', rich: '\u{1F4E6}' },
+    recording: { plain: '', rich: '\u{1F4BE}' },
+});