@williamthorsen/nmr 0.31.0 → 0.32.0

package/.readyup/kits/default.js

@@ -1,6 +1,6 @@
 /** @noformat — @generated. Do not edit. Compiled by rdy. */
 /* eslint-disable */
-export const __readyupVersion = "0.27.0";
+export const __readyupVersion = "0.28.0";
 
 
 // .readyup/kits/default.ts
@@ -179,6 +179,13 @@ var default_default = defineRdyKit({
           check: toolVersionsHasNoPnpm,
           fix: "Remove pnpm from .tool-versions \u2014 manage via packageManager field and corepack"
         },
+        {
+          name: "no package.json declares a pnpm field",
+          severity: "error",
+          quiet: true,
+          check: () => noPnpmFieldInPackageJson(),
+          fix: "Move these settings into pnpm-workspace.yaml, quoting each version under `overrides`, or run `pnpx codemod run pnpm-v10-to-v11`. pnpm 11 reads no key from the `pnpm` field, so an override left there pins nothing while an upgrade run with `--write` goes on rewriting it"
+        },
         {
           name: ".config/nmr.config.ts uses defineConfig",
           severity: "recommend",
@@ -387,7 +394,7 @@ function formatPaths(paths) {
 ${paths.map((path2) => `      ${path2}`).join("\n")}`;
 }
 function getMinVersion() {
-  const picked = { "version": "0.31.0" };
+  const picked = { "version": "0.32.0" };
   if (typeof picked["version"] !== "string") {
     throw new TypeError("nmr/package.json: 'version' must be a string");
   }
@@ -413,6 +420,15 @@ function isReExportOnly(content) {
   const statements = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "").split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
   return statements.length > 0 && statements.every((line) => RE_EXPORT_LINE_PATTERN.test(line));
 }
+function noPnpmFieldInPackageJson(cwd = process.cwd()) {
+  const declaring = findFiles(["**/package.json"], cwd).flatMap((relativePath) => {
+    const keys = readPnpmFieldKeys(readFileIn(cwd, relativePath));
+    if (keys === void 0) return [];
+    return [keys.length > 0 ? `${relativePath} (${keys.join(", ")})` : relativePath];
+  });
+  if (declaring.length === 0) return true;
+  return { ok: false, detail: formatPaths(declaring) };
+}
 function noReExportOnlyVitestConfigs(cwd = process.cwd()) {
   const nonRootConfigs = findFiles([`**/vitest.config.${CONFIG_EXTENSIONS}`], cwd).filter((path2) => path2.includes("/"));
   const reExports = nonRootConfigs.filter((path2) => isReExportOnly(readFileIn(cwd, path2)));
@@ -464,6 +480,18 @@ function readFileIn(cwd, relativePath) {
     return void 0;
   }
 }
+function readPnpmFieldKeys(content) {
+  if (content === void 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) return void 0;
+  const pnpm = parsed["pnpm"];
+  return isRecord(pnpm) ? Object.keys(pnpm).toSorted() : void 0;
+}
 function resolvesVersionViaWorkspace(range) {
   return WORKSPACE_VERSION_MARKERS.some((marker) => range.startsWith(marker));
 }
@@ -483,6 +511,7 @@ export {
   everyTestFileNamesItsTier,
   hasSupportedEslintVersion,
   hasSupportedStrictLintVersion,
+  noPnpmFieldInPackageJson,
   noReExportOnlyVitestConfigs,
   noRetiredVitestConfigs,
   prettierConfigBuildsOnSharedConfig,

package/.readyup/manifest.json

@@ -5,12 +5,43 @@
       "checklists": [
         "nmr"
       ],
+      "esbuildVersion": "0.28.1",
+      "inputs": [
+        {
+          "hash": "67afdcb4",
+          "kind": "module",
+          "path": "kits/default.ts"
+        },
+        {
+          "hash": "2bd89ec9",
+          "kind": "inline",
+          "path": "../package.json",
+          "paths": [
+            "version"
+          ]
+        },
+        {
+          "hash": "3dfc2ee7",
+          "kind": "module",
+          "path": "../src/default-scripts.ts"
+        },
+        {
+          "hash": "b42c7523",
+          "kind": "module",
+          "path": "../src/resolve-scripts.ts"
+        },
+        {
+          "hash": "c2d21075",
+          "kind": "module",
+          "path": "../src/tiers.ts"
+        }
+      ],
       "name": "default",
       "path": "kits/default.js",
-      "readyupVersion": "0.27.0",
+      "readyupVersion": "0.28.0",
       "source": "kits/default.ts",
-      "sourceHash": "7b2a223f",
-      "targetHash": "aaf561e4"
+      "sourceHash": "67afdcb4",
+      "targetHash": "b923a4b4"
     }
   ]
 }

package/README.md

@@ -3,69 +3,31 @@
 Context-aware script runner for pnpm monorepos. Ships an `nmr` (node-monorepo run) binary that provides centralized, consistent script execution across workspace packages and the monorepo root.
 
 <!-- section:release-notes -->
-## Release notes — v0.31.0 (2026-08-13)
+## Release notes — v0.32.0 (2026-08-17)
 
 ### 🎉 Features
 
-- Report a verdict for every command nmr runs (#659)
+- Carry the test-tier convention in the ambient rulebook (#689)
 
-  `nmr` now reports one line for every command it runs, naming the scope, command, outcome, and timing. The lines print in every verbosity, which makes `-q` the low-noise way to run rather than a silent one: a passing quiet run reports its verdicts and nothing else, so a pass, a cached skip, and a no-op override stay distinguishable.
-
-  Verdicts nest. A composite reports alongside every command it expands into, while a `:pre`/`:post` hook leaf and a `--filter`/`--recursive` delegate report nothing, since each is already covered by the levels around it.
-
-- Resolve a run's verbosity from repo config and agent-harness detection (#660)
-
-  A verbosity preference for `nmr` can now be set in the repo's root config, and `nmr` now automatically switches to quiet mode when it detects a known agent harness. This makes four ways to set verbosity: the `-q` option, the `NMR_COMMAND_VERBOSITY` env var, config, and harness detection, consulted in that order and defaulting to `full` when none applies.
-
-- 🚨 **Breaking:** Refine nmr upgrade to support catalogs (#661)
-
-  Adds `nmr-report-catalog`, which names the dependencies a package takes from a pnpm catalog, their `catalog:` specifiers, and the monorepo root a covering pass runs from. The workspace `upgrade` default chains it ahead of the upgrade tool, and `nmr report-catalog` runs it alone. Because taze reads `pnpm-workspace.yaml` only when that file sits at its working directory, changes to the catalog are not attempted during a package-scoped upgrade.
-
-  Separately, `nmr-report-overrides` now reports the `overrides` block in `pnpm-workspace.yaml` and fails on a `pnpm.overrides` block in the root `package.json`. Both `upgrade` and `root:upgrade` run the reporter ahead of taze. This avoids a scenario where taze would meaninglessly write to the latter block.
-
-  Migration: Move the block to `overrides` in `pnpm-workspace.yaml`, quoting each version, or run `pnpx codemod run pnpm-v10-to-v11`. `engines` declares `pnpm: ">=11"`.
-
-- Replay an excerpt of the run a skip recalls (#667)
-
-  `nmr` can now show the result of the previous check when a check is skipped. When `nmr` runs a command, it stores the result, keyed by presentation environment. The result is deemed to be the last blank-line-delimited block written by the command. If the command is run again in the same presentation environment, the stored result is shown, labeled "replayed:" for clarity.
-
-- Assemble a skipped composite's replay from its constituents' excerpts (#668)
-
-  A skipped composite now replays what its constituents recorded, with each line attributed to the scope and command that produced it:
-
-  ```console
-  ⏭️ nmr: check: passed 35.7s ago on this tree, saved ~10s — replayed: nmr: fmt:check: All matched files use Prettier code style!; nmr: test: Test Files 52 passed (52) Tests 987 passed (987)
-  ```
-
-  Nesting collapses. A constituent that fans out across packages contributes a line from every package that recorded one; a constituent that recorded nothing is omitted.
-
-  A new reserved variable, `NMR_RUN_ID`, carries a run's identity to every process below it. Every recorded excerpt names the run that last certified it. A composite summary includes saved results with the same status as a fresh result.
-
-- Print a retained run with nmr --log (#669)
-
-  Adds `nmr --log <command>`, which prints what the last recorded pass wrote instead of running the command again. The whole transcript, up to a limit of 256 KiB, is now saved for any passing command that is not writing straight to a terminal; `--log` prints it under a header giving the instant, the duration, and the command chain that succeeded. The log of a composite is the sum of its constituents' excerpts. If a change disqualifies the recording, `--log` instead reports the change.
-
-- Emit one JSON object per command for machine consumers (#672)
-
-  Adds `--json` to `nmr`, allowing the caller to request output in JSON format instead of prose. An env var carries the choice of `json` or `text` down a spawned chain. When the output is JSON, the consumer receives one JSON object per command; each object carries the command, scope, and outcome, and a recalled pass carries the recorded excerpts.
+  Adds the test-tier convention to `nmr.md`, the ambient rulebook `codeassembly sync` deploys to each consuming repo's agent guidance. The guidance describes the `<subject>[.<aspect>].<tier>.test.ts` grammar and the four tiers, and warns that tests outside a `__tests__` directory are ignored. Tests not explicitly attributed to a tier are flagged by the ReadyUp kit bundled with `nmr`.
+  
+  The previous guidance is removed from `AGENTS.md`.
 
-  The mode implies quiet. Stdout carries the objects alone (with no prose verdict line and no override notice); a failing command still displays its output on stderr.
+- Close each bin's output with a statement of what the run came to (#691)
 
-- 🚨 **Breaking:** Bind trailing arguments to every step that accepts them (#675)
+  Five nmr bins now end their output with a statement of the run's final result, rather than on whichever line the run happened to reach last, so the last line a reader sees carries the finding.
 
-  Routes an argument passed to an `nmr` command to every step of that command that accepts it, in place of the last step alone. Thus, `nmr test <file>` therefore runs only that file's tests; previously, the root suite ran in full alongside the narrowed package runs. Steps by default accept passed arguments, but can be configured to ignore them. If no step of a command accepts the argument, `nmr` names the command and runs nothing.
+  Separately, `ensure-prepublish-hooks` prints its whole report, including failure messages, on stdout, to avoid splitting the report across two streams. Failure still results in a non-zero exit code.
 
-  A command carrying an argument also reads the check-result cache nowhere in its chain, so it no longer skips part of its work from a pass recorded for an unnarrowed run.
+- Reject a dead pnpm field in nmr's ReadyUp kit (#692)
 
-  Migration: Existing configs need no change, since a bare string element keeps its present meaning. Two behaviors differ: A composite passes its arguments to every accepting step rather than to its final step alone; and `nmr typecheck <file>` at the repo root is refused, where it previously checked that file under default compiler options at the root and hunted for it in every package.
+  nmr's ReadyUp kit now checks for the presence of a `pnpm` field in any `package.json`. pnpm 11 no longer reads any key from that field, but taze (the engine underlying `nmr upgrade`) reads `pnpm.overrides`. To avoid confusion, the kit flags this as an error.
 
 ### 🐛 Bug fixes
 
-- Derive the shelled-nmr remedy from the declaration site and reject a malformed package.json (#658)
+- Fold the running nmr's fingerprint into the build cache key (#693)
 
-  Fixes a shelled-nmr warning that named `.config/nmr.config.ts` as the remedy for every step it reported, including the `package.json` entries that tier cannot resolve. The line now names the relevant declaration and remedy. Shelled nmr can now be detected not only in a step's first token but anywhere in the step.
-  
-  Separately, a configuration mistake now reports as a plain message rather than a Node stack trace.
+  Fixes the issue that build output could be stale, but not reported to be stale, after an edit to `nmr-compile`'s own emit logic. The build cache key now folds a fingerprint of the `nmr` running the build alongside the TypeScript version it already carried. Any build keys generated against an `nmr` with a different fingerprint will be invalidated. Repos consuming `nmr` get the same behavior.
 <!-- /section:release-notes -->
 
 ## Installation
@@ -883,7 +845,7 @@ nmr-clean
 
 ### `nmr-compile`
 
-Compile a single package's `src` tree to `dist/esm` with the TypeScript compiler API, emitting `.js` and `.d.ts` in one pass. Because the compiler parses each source file, every relative import form — static, re-export, dynamic `import()`, and bare side-effect — is rewritten from `.ts` to `.js` in both outputs, and `.ts` occurrences inside strings and comments are left intact. tsconfig `paths` aliases are resolved to runnable relative `.js` specifiers in both outputs, sourced from the package's tsconfig. An aliased import whose target resolves outside the package's `src/` and is not resolvable without the alias mapping fails the build with a diagnostic, rather than being emitted verbatim to produce output that fails at runtime. The build is skipped when no input has changed and the previous output is still on disk (a content-and-path hash is cached under `node_modules/.cache/nmr-compile/`, outside the published output). Deleting the output by any means — `nmr clean`, `rm -rf dist`, `git clean` — therefore forces a rebuild rather than a skip. This is the default `compile` script — run it from a package directory.
+Compile a single package's `src` tree to `dist/esm` with the TypeScript compiler API, emitting `.js` and `.d.ts` in one pass. Because the compiler parses each source file, every relative import form — static, re-export, dynamic `import()`, and bare side-effect — is rewritten from `.ts` to `.js` in both outputs, and `.ts` occurrences inside strings and comments are left intact. tsconfig `paths` aliases are resolved to runnable relative `.js` specifiers in both outputs, sourced from the package's tsconfig. An aliased import whose target resolves outside the package's `src/` and is not resolvable without the alias mapping fails the build with a diagnostic, rather than being emitted verbatim to produce output that fails at runtime. The build is skipped when no input has changed and the previous output is still on disk (the key is cached under `node_modules/.cache/nmr-compile/`, outside the published output). Deleting the output by any means — `nmr clean`, `rm -rf dist`, `git clean` — therefore forces a rebuild rather than a skip. This is the default `compile` script — run it from a package directory.
 
 **What it compiles.** Entry points are `src/**/*.ts` less the directories that hold test scaffolding rather than shipped code: `__fixtures__/`, `__mocks__/`, `__tests__/`, and `test-utils/`. Add to that list per package with [`build.extraIgnorePatterns`](#package-level-configuration). Ignoring a directory drops it as an _entry point_, not from the emit: the compiler still emits whatever the surviving entry points import, so a helper that production code uses is still compiled and its importer never emits a dangling specifier. This list is deliberately not the Vitest [coverage exclusions](#what-the-config-excludes) — helpers live in `test-utils/` precisely so they stay covered.
 
@@ -891,6 +853,8 @@ Compile a single package's `src` tree to `dist/esm` with the TypeScript compiler
 
 **The replacement is atomic.** The emit is buffered in memory, written to a staging directory beside the output directory, and swapped into place by rename. A build that fails for any reason -- a malformed tsconfig, an unresolvable alias, a full disk -- therefore leaves the previous output exactly as it was. `dist/esm` is never observed mid-write: it holds the previous build or the new one, and is absent only between the two renames. This matters most when the package being rebuilt supplies a binary that other packages in the same recursive build invoke.
 
+**What busts the cache.** The key folds each input's content and path, the emit options, the resolved TypeScript version, and a fingerprint of the nmr running the build -- its own build digest in a workspace checkout, its package version otherwise. Upgrading nmr in a consuming repo therefore rebuilds every package nmr compiles, and an edit to nmr's own build sources rebuilds each sibling once nmr itself has been rebuilt. A build of nmr's own package folds the version rather than the digest, which is the cache entry that build is about to write.
+
 `typescript` is a peer dependency (`>=5.7.0 <7`); the consuming repo provides it. The floor is what `rewriteRelativeImportExtensions` requires; the ceiling is because TypeScript 7 ships no compiler API — its root export is a version constant, so `nmr-compile` cannot run on it. Relative imports in source must carry explicit `.ts` extensions for them to be rewritten.
 
 ```bash
@@ -940,7 +904,7 @@ ensure-prepublish-hooks
 
 ## Conformance checks
 
-nmr publishes a `readyup` kit that checks a consuming repo against the current release: the shared Vitest and Prettier configs, the workspace layout, the root script registry, and the [test-tier convention](#test-tiers). The kit ships inside the package, so it checks against the nmr version installed rather than whatever a repository ref happens to point at, and a tier added or renamed in nmr reaches the repo on upgrade.
+nmr publishes a `readyup` kit that checks a consuming repo against the current release: the shared Vitest and Prettier configs, the workspace layout, the root script registry, the [test-tier convention](#test-tiers), and that no `package.json` in the tree declares a `pnpm` field, which pnpm 11 reads no key from. Those settings belong in `pnpm-workspace.yaml`, and `pnpx codemod run pnpm-v10-to-v11` moves them. The kit ships inside the package, so it checks against the nmr version installed rather than whatever a repository ref happens to point at, and a tier added or renamed in nmr reaches the repo on upgrade.
 
 Add `readyup` as a devDependency, then name nmr in its config:
 

package/agents/guidance/rulebooks/nmr.md

@@ -13,4 +13,5 @@ delivery: ambient
 - 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.
 - `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.
-- 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), 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 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. Neither a file outside `__tests__` nor one whose tier segment is missing or misspelt fails anything: the first is collected by nothing and the second runs under `unit`, and no test run distinguishes either from a conformant file. `rdy run --packages` reports the misspelt tier, and nothing reports the misplaced file.
+- 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.

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

@@ -1,6 +1,6 @@
 import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
-import { DEFAULT_HOOK, ensurePrepublishHooks } from "./commands/ensure-prepublish-hooks.js";
+import { DEFAULT_HOOK, ensurePrepublishHooks, reportPrepublishHooks } from "./commands/ensure-prepublish-hooks.js";
 import { findMonorepoRoot } from "./workspace.js";
 const flagSchema = {
     fix: { long: '--fix', type: 'boolean' },
@@ -10,31 +10,10 @@ const flagSchema = {
 const { fix, dryRun, command } = parseArgsOrExit(process.argv.slice(2), flagSchema).flags;
 try {
     const monorepoRoot = findMonorepoRoot();
-    const hookCommand = command ?? DEFAULT_HOOK;
     const options = command ? { fix, dryRun, command } : { fix, dryRun };
     const result = ensurePrepublishHooks(monorepoRoot, options);
-    for (const pkg of result.packages) {
-        if (pkg.isPrivate) {
-            continue;
-        }
-        switch (pkg.action) {
-            case 'ok':
-                console.info(`✓ ${pkg.packageName}: prepublishOnly = "${pkg.prepublishOnly}"`);
-                break;
-            case 'missing':
-                console.warn(`✗ ${pkg.packageName}: missing prepublishOnly`);
-                break;
-            case 'fixed':
-                console.info(`✓ ${pkg.packageName}: added prepublishOnly = "${hookCommand}"`);
-                break;
-            case 'would-fix':
-                console.info(`~ ${pkg.packageName}: would add prepublishOnly = "${hookCommand}"`);
-                break;
-        }
-    }
+    reportPrepublishHooks(result, command ?? DEFAULT_HOOK);
     if (result.hasFailures) {
-        const missing = result.packages.filter((p) => p.action === 'missing').length;
-        process.stderr.write(`\n${missing} package(s) missing prepublishOnly. Use --fix to add it.\n`);
         process.exitCode = 1;
     }
 }

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

@@ -16,3 +16,4 @@ export declare function hasExpectedBuildOutput(packageDir: string, outdir: strin
 export declare function readBuildDigest(packageDir: string): Promise<string | undefined>;
 export declare function resolveBuildCachePath(packageDir: string): string;
 export declare function resolveScratchDirs(emitDir: string): ScratchDirs;
+export declare function resolveToolchainFingerprint(packageDir: string, selfDir?: string): Promise<string>;

package/dist/esm/commands/build-output.js

@@ -1,11 +1,13 @@
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync, readdirSync, realpathSync } from 'node:fs';
 import path from 'node:path';
-import { readCacheEntry, resolveCacheEntryPath } from '@williamthorsen/nmr-core';
+import { findPackageRoot, readCacheEntry, resolveCacheEntryPath } from '@williamthorsen/nmr-core';
 import { glob } from 'glob';
+import { readPackageJson } from "../helpers/package-json.js";
 export const DEFAULT_ENTRY_GLOBS = ['src/**/*.ts'];
 export const DEFAULT_IGNORE_PATTERNS = ['**/__fixtures__/**', '**/__mocks__/**', '**/__tests__/**', '**/test-utils/**'];
 export const DEFAULT_OUTDIR = 'dist/esm/';
 const BUILD_CACHE_TOOL = 'nmr-compile';
+const SELF_DIR = findPackageRoot(import.meta.url);
 export async function hasBuildOutput(packageDir, options = {}) {
     const outdir = options.outdir ?? DEFAULT_OUTDIR;
     const entryPoints = await glob(options.entryGlobs ?? DEFAULT_ENTRY_GLOBS, {
@@ -42,3 +44,24 @@ export function resolveScratchDirs(emitDir) {
         staging: path.join(parent, `.${name}.staging`),
     };
 }
+export async function resolveToolchainFingerprint(packageDir, selfDir = SELF_DIR) {
+    if (!isSameDir(packageDir, selfDir)) {
+        const digest = await readBuildDigest(selfDir);
+        if (digest !== undefined) {
+            return digest;
+        }
+    }
+    return readPackageJson(selfDir).version ?? '';
+}
+function isSameDir(left, right) {
+    return toRealPath(left) === toRealPath(right);
+}
+function toRealPath(dir) {
+    const absolute = path.resolve(dir);
+    try {
+        return realpathSync(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}

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

@@ -1,4 +1,8 @@
 import type { BuildOptions } from './build-output.js';
+export interface BuildToolchain {
+    compilerVersion: string;
+    fingerprint: string;
+}
 export declare function buildPackage(packageDir: string, options?: BuildOptions): Promise<void>;
-export declare function computeBuildHash(packageDir: string, files: string[], emitConfig: object, compilerVersion: string): Promise<string>;
+export declare function computeBuildHash(packageDir: string, files: string[], emitConfig: object, toolchain: BuildToolchain): Promise<string>;
 export declare function resolveTsconfigChain(packageDir: string, configFileName?: string): string[];

package/dist/esm/commands/build.js

@@ -6,7 +6,7 @@ import { readCacheEntry, writeCacheEntry } from '@williamthorsen/nmr-core';
 import { glob } from 'glob';
 import * as ts from 'typescript';
 import { resolveConfigPath } from "../config.js";
-import { DEFAULT_ENTRY_GLOBS, DEFAULT_IGNORE_PATTERNS, DEFAULT_OUTDIR, hasExpectedBuildOutput, resolveBuildCachePath, resolveScratchDirs, } from "./build-output.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';
@@ -30,15 +30,20 @@ export async function buildPackage(packageDir, options = {}) {
         ...(existsSync(configPath) ? [path.relative(packageDir, configPath)] : []),
         ...resolveTsconfigChain(packageDir),
     ];
-    const { changed, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, ts.version, cachePath, hasExpectedBuildOutput(packageDir, outdir, entryPoints));
+    const toolchain = {
+        compilerVersion: ts.version,
+        fingerprint: await resolveToolchainFingerprint(packageDir),
+    };
+    const { changed, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, toolchain, cachePath, hasExpectedBuildOutput(packageDir, outdir, entryPoints));
     if (!changed) {
         await discardScratchDirs(resolveScratchDirs(emitDir));
         return;
     }
-    await emitPackage(packageDir, entryPoints, outdir);
+    const emittedFileCount = await emitPackage(packageDir, entryPoints, outdir);
     await writeCacheEntry(cachePath, currentHash);
+    console.info(`${PACKAGE_ICON} ${path.basename(packageDir)}: ${describeEmit(emittedFileCount, outdir)}`);
 }
-export async function computeBuildHash(packageDir, files, emitConfig, compilerVersion) {
+export async function computeBuildHash(packageDir, files, emitConfig, toolchain) {
     const hash = createHash('sha256');
     for (const file of files.toSorted()) {
         hash.update(file);
@@ -47,7 +52,9 @@ export async function computeBuildHash(packageDir, files, emitConfig, compilerVe
     }
     hash.update(JSON.stringify(emitConfig));
     hash.update('\0');
-    hash.update(compilerVersion);
+    hash.update(toolchain.compilerVersion);
+    hash.update('\0');
+    hash.update(toolchain.fingerprint);
     return hash.digest('hex');
 }
 export function resolveTsconfigChain(packageDir, configFileName = 'tsconfig.json') {
@@ -92,10 +99,11 @@ async function emitPackage(packageDir, entryPoints, outdir) {
     }
     if (staged.size === 0) {
         await rm(emitDir, { force: true, recursive: true });
-        return;
+        return 0;
     }
     writeStagedOutput(staged, emitDir, scratchDirs.staging);
     await swapIntoPlace(emitDir, scratchDirs);
+    return staged.size;
 }
 async function discardScratchDirs(scratchDirs) {
     try {
@@ -247,10 +255,10 @@ function getModuleSpecifier(node) {
     }
     return undefined;
 }
-async function detectBuildChanges(packageDir, files, emitConfig, compilerVersion, cachePath, outputPresent) {
+async function detectBuildChanges(packageDir, files, emitConfig, toolchain, cachePath, outputPresent) {
     const packageName = path.basename(packageDir);
     const previousHash = await readCacheEntry(cachePath);
-    const currentHash = await computeBuildHash(packageDir, files, emitConfig, compilerVersion);
+    const currentHash = await computeBuildHash(packageDir, files, emitConfig, toolchain);
     if (previousHash === currentHash) {
         if (outputPresent) {
             console.info(`${SKIPPED_ICON} ${packageName}: No changes detected. Skipping build.`);
@@ -278,6 +286,12 @@ function collectAliasPrefixes(compilerOptions) {
     }
     return Object.keys(compilerOptions.paths).map((pattern) => pattern.replace(/\*$/, ''));
 }
+function describeEmit(fileCount, outdir) {
+    if (fileCount === 0) {
+        return 'Emitted no output.';
+    }
+    return `Compiled ${fileCount} files to ${outdir.replace(/\/+$/u, '')}.`;
+}
 function formatDiagnostics(diagnostics) {
     return ts.formatDiagnosticsWithColorAndContext(diagnostics, {
         getCurrentDirectory: () => process.cwd(),

package/dist/esm/commands/clean.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { removeCheckCache } from "../check-cache.js";
 import { loadRootConfig } from "../config.js";
 import { findContainingPackageDir } from "../context.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";
@@ -40,17 +41,26 @@ async function clearCheckCache(scopeDir) {
     await removeCheckCache(scopeDir);
     console.info(`${CLEAN_ICON} 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) {
     const config = await loadRootConfig(monorepoRoot);
     const registry = buildWorkspaceRegistry(config);
+    let cleaned = 0;
+    let skipped = 0;
     for (const packageDir of workspacePackageDirs) {
         const resolved = resolveScript(CLEAN_COMMAND, registry, packageDir, false);
         const resolvedCommand = resolved === undefined ? undefined : renderChain(resolved.steps);
         if (resolvedCommand === undefined || resolvedCommand === '') {
+            skipped++;
             continue;
         }
         if (resolvedCommand === BUILT_IN_CLEAN) {
             await cleanPackage(packageDir);
+            cleaned++;
             continue;
         }
         const command = applyDevBin(resolvedCommand, config.devBin, monorepoRoot);
@@ -60,5 +70,7 @@ async function sweepWorkspace(monorepoRoot, workspacePackageDirs) {
         if (exitCode !== 0) {
             throw new Error(`nmr-clean: \`${command}\` failed in ${path.basename(packageDir)} with exit code ${exitCode}.`);
         }
+        cleaned++;
     }
+    reportClosing(`${CLEAN_ICON} ${describeSweep(cleaned, skipped)}`);
 }

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

@@ -15,3 +15,4 @@ export declare function ensurePrepublishHooks(monorepoRoot: string, options: {
     dryRun: boolean;
     command?: string;
 }): EnsurePrepublishHooksResult;
+export declare function reportPrepublishHooks(result: EnsurePrepublishHooksResult, hookCommand: string): void;

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

@@ -1,6 +1,7 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { readPackageJson } from "../helpers/package-json.js";
+import { reportClosing } from "../helpers/reportClosing.js";
 import { isObject } from "../helpers/type-guards.js";
 import { getWorkspacePackageDirs } from "../workspace.js";
 export const DEFAULT_HOOK = 'npm run build';
@@ -59,6 +60,17 @@ export function ensurePrepublishHooks(monorepoRoot, options) {
     const hasFailures = packages.some((p) => p.action === 'missing');
     return { packages, hasFailures };
 }
+export function reportPrepublishHooks(result, hookCommand) {
+    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));
+    }
+    reportClosing(describeHookRun(publishable));
+}
 function addPrepublishOnly(packageDir, command) {
     const filePath = path.join(packageDir, 'package.json');
     const raw = readFileSync(filePath, 'utf8');
@@ -71,3 +83,34 @@ function addPrepublishOnly(packageDir, command) {
     parsed['scripts'] = scripts;
     writeFileSync(filePath, JSON.stringify(parsed, null, 2) + '\n', 'utf8');
 }
+function countAction(publishable, action) {
+    return publishable.filter((pkg) => pkg.action === action).length;
+}
+function describeHookRun(publishable) {
+    const packages = publishable.length === 1 ? '1 publishable package' : `${publishable.length} publishable packages`;
+    const missing = countAction(publishable, 'missing');
+    if (missing > 0) {
+        return `${missing} of ${packages} ${missing === 1 ? 'is' : 'are'} missing prepublishOnly. Run with --fix to add it.`;
+    }
+    const fixed = countAction(publishable, 'fixed');
+    if (fixed > 0) {
+        return `Added prepublishOnly to ${fixed} of ${packages}.`;
+    }
+    const wouldFix = countAction(publishable, 'would-fix');
+    if (wouldFix > 0) {
+        return `Would add prepublishOnly to ${wouldFix} of ${packages}.`;
+    }
+    return `${packages} ${publishable.length === 1 ? 'has' : 'have'} prepublishOnly.`;
+}
+function renderHookStatus(pkg, hookCommand) {
+    switch (pkg.action) {
+        case 'ok':
+            return `✓ ${pkg.packageName}: prepublishOnly = "${pkg.prepublishOnly}"`;
+        case 'missing':
+            return `✗ ${pkg.packageName}: missing prepublishOnly`;
+        case 'fixed':
+            return `✓ ${pkg.packageName}: added prepublishOnly = "${hookCommand}"`;
+        case 'would-fix':
+            return `~ ${pkg.packageName}: would add prepublishOnly = "${hookCommand}"`;
+    }
+}

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

@@ -1,6 +1,8 @@
 import { findContainingPackageDir } from "../context.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) {
     const monorepoRoot = findMonorepoRoot(cwd);
@@ -12,12 +14,16 @@ export function reportCatalog(cwd) {
     if (dependencies.length === 0) {
         return;
     }
-    const subject = dependencies.length === 1 ? '1 dependency comes' : `${dependencies.length} dependencies come`;
-    console.warn(`📚 WARN: ${subject} from a catalog, which a package-scoped upgrade does not read:`);
+    console.warn(`${CATALOG_ICON} WARN: A package-scoped upgrade does not read the catalogs these come from:`);
     for (const { name, specifier } of dependencies) {
         console.warn(`- ${name} → ${specifier}`);
     }
-    console.warn(`Run \`nmr upgrade\` from ${monorepoRoot} to include them.`);
+    reportClosing(`${CATALOG_ICON} ${describeCatalog(dependencies.length, monorepoRoot)}`, console.warn);
+}
+function describeCatalog(count, monorepoRoot) {
+    const subject = count === 1 ? '1 catalogued dependency went' : `${count} catalogued dependencies went`;
+    const object = count === 1 ? 'it' : 'them';
+    return `${subject} unread. Run \`nmr upgrade\` from ${monorepoRoot} to include ${object}.`;
 }
 function findCataloguedDependencies(packageDir) {
     const pkg = readPackageJson(packageDir);

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

@@ -1,16 +1,24 @@
 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) {
     const declared = listEntries(readWorkspaceOverrides(monorepoRoot));
     if (declared.length > 0) {
-        console.warn('🔒 WARN: pnpm overrides are active! Check whether these are still needed:');
+        console.warn(`${OVERRIDES_ICON} WARN: pnpm overrides are active:`);
         for (const [name, version] of declared) {
             console.warn(`- ${name} → ${version}`);
         }
+        reportClosing(`${OVERRIDES_ICON} ${describeOverrides(declared.length)}`, console.warn);
     }
     rejectLegacyOverrides(monorepoRoot);
 }
+function describeOverrides(count) {
+    return count === 1
+        ? '1 override is active. Check whether it is still needed.'
+        : `${count} overrides are active. Check whether they are still needed.`;
+}
 function listEntries(overrides) {
     return Object.entries(overrides ?? {}).toSorted(([a], [b]) => a.localeCompare(b));
 }

package/dist/esm/helpers/reportClosing.d.ts

@@ -0,0 +1 @@
+export declare function reportClosing(message: string, log?: (line: string) => void): void;

package/dist/esm/helpers/reportClosing.js

@@ -0,0 +1,3 @@
+export function reportClosing(message, log = console.info) {
+    log(`\n${message}`);
+}

package/dist/esm/reportCliFailure.js

@@ -1,11 +1,11 @@
 import { reportError } from '@williamthorsen/nmr-core';
-import { describeError } from '@williamthorsen/toolbelt.errors';
+import { describeError, isError } from '@williamthorsen/toolbelt.errors';
 import { UserError } from "./UserError.js";
 export function reportCliFailure(error, stderr) {
     if (error instanceof UserError) {
         reportError(error.message, stderr);
         return;
     }
-    const detail = error instanceof Error && error.stack !== undefined ? error.stack : describeError(error);
+    const detail = isError(error) && error.stack !== undefined ? error.stack : describeError(error);
     stderr.write(`${detail}\n`);
 }

package/dist/esm/resolver.js

@@ -1,5 +1,6 @@
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
+import { hasErrnoCode } from '@williamthorsen/nmr-core';
 import { parsePackageJson, readScriptRecord, resolvePackageJsonPath } from "./helpers/package-json.js";
 import { isObject } from "./helpers/type-guards.js";
 import { getDefaultRootScripts, getDefaultWorkspaceScripts } from "./resolve-scripts.js";
@@ -62,7 +63,7 @@ export function readPackageJsonScripts(packageDir) {
         raw = readFileSync(file, 'utf8');
     }
     catch (error) {
-        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+        if (hasErrnoCode(error, 'ENOENT')) {
             return undefined;
         }
         throw error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/nmr",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "private": false,
   "description": "Context-aware script runner for pnpm monorepos",
   "keywords": [
@@ -68,16 +68,18 @@
     "dist"
   ],
   "dependencies": {
-    "@williamthorsen/toolbelt.errors": "0.4.0",
+    "@williamthorsen/toolbelt.errors": "0.5.0",
     "glob": "13.0.6",
     "prettier-plugin-sh": "0.19.0",
-    "taze": "20.0.0",
+    "taze": "20.0.1",
     "yaml": "2.9.0",
-    "@williamthorsen/nmr-core": "0.10.0"
+    "@williamthorsen/nmr-core": "0.10.1"
   },
   "devDependencies": {
+    "@williamthorsen/toolbelt.testing": "0.3.0",
+    "@williamthorsen/toolbelt.vitest": "0.4.0",
     "prettier": "3.9.6",
-    "readyup": "0.27.0",
+    "readyup": "0.28.0",
     "tinyglobby": "0.2.17",
     "typescript": "6.0.3",
     "vitest": "4.1.10"