@williamthorsen/nmr 0.24.0 → 0.26.0

package/.readyup/kits/default.js

@@ -0,0 +1,467 @@
+/** @noformat — @generated. Do not edit. Compiled by rdy. */
+/* eslint-disable */
+export const __readyupVersion = "0.23.0";
+
+
+// .readyup/kits/default.ts
+import { existsSync, globSync, readdirSync as readdirSync2, readFileSync } from "node:fs";
+import { basename, join, sep } from "node:path";
+import { defineRdyKit } from "readyup";
+import {
+  fileContains,
+  fileExists,
+  hasDevDependency,
+  hasMinDevDependencyVersion,
+  hasPackageJsonField,
+  isRecord,
+  readFile,
+  readPackageJson
+} from "readyup/check-utils";
+
+// src/default-scripts.ts
+var GATE_PROJECTS = "--project unit --project tool";
+var workspaceScripts = {
+  build: ["compile"],
+  check: ["typecheck", "fmt:check", "lint:check", "test"],
+  "check:strict": ["typecheck", "fmt:check", "lint:strict", "test:coverage"],
+  clean: "nmr-clean",
+  compile: "nmr-compile",
+  fix: ["lint", "fmt"],
+  "fix:check": ["fmt:check", "lint:check"],
+  fmt: "nmr-fmt --write",
+  "fmt:check": "nmr-fmt --check",
+  lint: "eslint --fix .",
+  "lint:check": "eslint .",
+  "lint:strict": "strict-lint",
+  test: `pnpm exec vitest ${GATE_PROJECTS}`,
+  "test:all": "pnpm exec vitest",
+  "test:coverage": `pnpm exec vitest ${GATE_PROJECTS} --coverage`,
+  "test:tool": "pnpm exec vitest --project tool",
+  "test:unit": "pnpm exec vitest --project unit",
+  "test:watch": `pnpm exec vitest ${GATE_PROJECTS} --watch`,
+  typecheck: "tsgo --noEmit",
+  // Without `--include-locked`, nothing would be reported in a repo that pins exact version numbers.
+  upgrade: "nmr-taze --include-locked",
+  "view-coverage": "open coverage/index.html"
+};
+var rootScripts = {
+  audit: ["audit:prod", "audit:dev"],
+  "audit:dev": "pnpm exec v11y --dev",
+  "audit:prod": "pnpm exec v11y --prod",
+  build: "pnpm --recursive exec nmr build",
+  check: ["typecheck", "fmt:check", "lint:check", "test"],
+  "check:strict": ["typecheck", "fmt:check", "lint:strict", "test:coverage"],
+  // Excludes the audit, which in CI has a workflow of its own.
+  ci: ["build", "check:strict"],
+  clean: "nmr-clean",
+  fix: ["lint", "fmt"],
+  "fix:check": ["fmt:check", "lint:check"],
+  fmt: "nmr-fmt --write",
+  "fmt:check": "nmr-fmt --check",
+  lint: "nmr root:lint && pnpm --recursive exec nmr lint",
+  "lint:check": "nmr root:lint:check && pnpm --recursive exec nmr lint:check",
+  "lint:strict": "nmr root:lint:strict && pnpm --recursive exec nmr lint:strict",
+  prepush: ["ci", "audit"],
+  "report-overrides": "nmr-report-overrides",
+  "root:check": ["root:typecheck", "fmt:check", "root:lint:check", "root:test"],
+  "root:lint": "eslint --fix --ignore-pattern 'packages/**' .",
+  "root:lint:check": "eslint --ignore-pattern 'packages/**' .",
+  "root:lint:strict": "strict-lint --ignore-pattern 'packages/**' .",
+  "root:test": `vitest --config ./vitest.root.config.ts ${GATE_PROJECTS}`,
+  "root:test:all": "vitest --config ./vitest.root.config.ts",
+  "root:test:tool": "vitest --config ./vitest.root.config.ts --project tool",
+  "root:test:unit": "vitest --config ./vitest.root.config.ts --project unit",
+  "root:typecheck": "tsgo --noEmit",
+  "root:upgrade": "nmr-taze --include-locked",
+  test: "nmr root:test && pnpm --recursive exec nmr test",
+  "test:all": "nmr root:test:all && pnpm --recursive exec nmr test:all",
+  "test:coverage": "nmr root:test && pnpm --recursive exec nmr test:coverage",
+  "test:tool": "nmr root:test:tool && pnpm --recursive exec nmr test:tool",
+  "test:unit": "nmr root:test:unit && pnpm --recursive exec nmr test:unit",
+  // Bare `vitest` at the monorepo root resolves the root `vitest.config.ts`, covering the whole tree in one
+  // process; a chain like the others would never advance past its first watcher.
+  "test:watch": `vitest ${GATE_PROJECTS} --watch`,
+  typecheck: "nmr root:typecheck && pnpm --recursive exec nmr typecheck",
+  // A string rather than a composite: Passthrough args attach to the chain's last command.
+  upgrade: "nmr-report-overrides && nmr-taze --include-locked --recursive"
+};
+
+// src/resolve-scripts.ts
+function getDefaultRootScripts() {
+  return { ...rootScripts };
+}
+
+// src/tiers.ts
+import { readdirSync } from "node:fs";
+import path from "node:path";
+var TEST_DIR = "__tests__";
+var TEST_EXTENSIONS = "{ts,tsx}";
+var TEST_GLOB_PREFIX = `**/${TEST_DIR}/**`;
+var TEST_FILE_PATTERN = /\.test\.tsx?$/;
+var ALL_TEST_PATTERNS = [`${TEST_GLOB_PREFIX}/*.test.${TEST_EXTENSIONS}`];
+function findTestFiles(rootDir) {
+  const found = [];
+  collectTestFiles(rootDir, "", false, found);
+  return found.toSorted();
+}
+function hasTierInfix(filePath) {
+  const tiers = TIER_NAMES;
+  return tiers.includes(path.basename(filePath).split(".").at(-3) ?? "");
+}
+var TEST_COLLECTION_EXCLUDE = [".git", "coverage", "dist", "node_modules"];
+var TIER_NAMES = ["unit", "tool", "localhost", "remote"];
+function collectTestFiles(dir, relativeDir, inTestDir, found) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const relativePath = relativeDir === "" ? entry.name : `${relativeDir}/${entry.name}`;
+    if (entry.isDirectory()) {
+      if (TEST_COLLECTION_EXCLUDE.includes(entry.name)) continue;
+      collectTestFiles(path.join(dir, entry.name), relativePath, inTestDir || entry.name === TEST_DIR, found);
+    } else if (inTestDir && TEST_FILE_PATTERN.test(entry.name)) {
+      found.push(relativePath);
+    }
+  }
+}
+
+// .readyup/kits/default.ts
+var default_default = defineRdyKit({
+  checklists: [
+    {
+      name: "nmr",
+      checks: [
+        // -- Setup ---------------------------------------------------------------
+        {
+          name: "@williamthorsen/nmr in devDependencies",
+          severity: "error",
+          check: () => hasDevDependency("@williamthorsen/nmr"),
+          fix: "pnpm add --save-dev @williamthorsen/nmr",
+          checks: [
+            {
+              get name() {
+                return `@williamthorsen/nmr >= ${getMinVersion()}`;
+              },
+              severity: "error",
+              check: () => hasMinDevDependencyVersion("@williamthorsen/nmr", getMinVersion(), {
+                exempt: (range) => range.startsWith("workspace:")
+              }),
+              get fix() {
+                return `pnpm add --save-dev @williamthorsen/nmr@^${getMinVersion()}`;
+              }
+            }
+          ]
+        },
+        {
+          name: "pnpm-workspace.yaml exists",
+          severity: "error",
+          check: () => fileExists("pnpm-workspace.yaml"),
+          fix: "Create pnpm-workspace.yaml with workspace package globs"
+        },
+        {
+          name: "package.json has packageManager field",
+          severity: "warn",
+          check: () => hasPackageJsonField("packageManager"),
+          fix: 'Add "packageManager" field to package.json (e.g., "pnpm@10.33.0")'
+        },
+        {
+          name: ".tool-versions does not list pnpm",
+          severity: "warn",
+          check: toolVersionsHasNoPnpm,
+          fix: "Remove pnpm from .tool-versions \u2014 manage via packageManager field and corepack"
+        },
+        {
+          name: ".config/nmr.config.ts uses defineConfig",
+          severity: "recommend",
+          skip: () => !fileExists(".config/nmr.config.ts") ? "no nmr config file" : false,
+          check: () => fileContains(".config/nmr.config.ts", /defineConfig/),
+          fix: "Wrap your config export with defineConfig() from @williamthorsen/nmr/config for type safety"
+        },
+        // -- Root script cleanup -------------------------------------------------
+        {
+          name: "root package.json has no nmr-provided scripts",
+          severity: "warn",
+          check: noRedundantRootScripts,
+          fix: "Remove scripts from root package.json that nmr provides as built-in root scripts \u2014 invoke via nmr directly"
+        },
+        {
+          name: "root:lint:strict does not use echo fallback",
+          severity: "warn",
+          skip: () => !scriptExists("root:lint:strict") ? "no root:lint:strict script" : false,
+          check: () => !scriptMatches("root:lint:strict", /\becho\b/),
+          fix: "Replace the echo fallback in root:lint:strict \u2014 strict-lint now supports path arguments"
+        },
+        // -- Workspace build readiness -------------------------------------------
+        {
+          name: "all workspace packages can build",
+          severity: "warn",
+          check: allWorkspacePackagesCanBuild,
+          fix: `Add "build": ":" to packages that don't need a build, or ensure packages that use the default nmr build have a tsconfig.json and a src/ directory`
+        },
+        // -- Vitest projects -----------------------------------------------------
+        {
+          name: "no retired Vitest config variants",
+          severity: "error",
+          check: () => noRetiredVitestConfigs(),
+          fix: "Delete every vitest.standalone.config.* and vitest.integration.config.*. nmr's test scripts select Vitest projects instead of naming config files"
+        },
+        {
+          name: "vitest.config.ts builds on @williamthorsen/nmr/vitest",
+          severity: "error",
+          check: () => vitestConfigBuildsOnSharedConfig(),
+          fix: "Replace vitest.config.ts with: import { defineVitestConfig } from '@williamthorsen/nmr/vitest'; export default defineVitestConfig();"
+        },
+        {
+          name: "vitest.root.config.ts builds on @williamthorsen/nmr/vitest",
+          severity: "error",
+          check: () => vitestRootConfigBuildsOnSharedConfig(),
+          fix: "Replace vitest.root.config.ts with: import { defineRootVitestConfig } from '@williamthorsen/nmr/vitest'; export default defineRootVitestConfig({ monorepoRoot: import.meta.dirname });"
+        },
+        {
+          name: "every test file names its isolation tier",
+          severity: "error",
+          check: () => everyTestFileNamesItsTier(),
+          fix: `Rename each to <subject>[.<aspect>].<tier>.test.ts, naming one of ${TIER_NAMES.join(", ")}. Use tool for a test that reaches a program the environment supplies, which is where a retired .int. or .integration. file belongs. Only the segment before .test. selects a project, so an untiered file runs under the residual unit project and reports success`
+        },
+        {
+          name: "no package re-exports the ancestor Vitest config",
+          severity: "recommend",
+          check: () => noReExportOnlyVitestConfigs(),
+          fix: "Delete these files. Vitest resolves config by walking up from the run root, so a per-package re-export is redundant"
+        },
+        // -- Shared Prettier config ----------------------------------------------
+        {
+          name: "Prettier config builds on @williamthorsen/nmr/prettier",
+          severity: "error",
+          check: () => prettierConfigBuildsOnSharedConfig(),
+          fix: "Replace the Prettier config with: import { definePrettierConfig } from '@williamthorsen/nmr/prettier'; export default definePrettierConfig();"
+        },
+        // -- Audit dependency --------------------------------------------------------
+        {
+          name: "v11y-check in devDependencies",
+          severity: "warn",
+          check: () => hasDevDependency("v11y-check"),
+          fix: "pnpm add --save-dev v11y-check"
+        },
+        {
+          name: "code-quality workflow does not use nmr prepush",
+          severity: "warn",
+          skip: () => !fileExists(".github/workflows/code-quality.yaml") ? "no code-quality workflow" : false,
+          check: codeQualityWorkflowDoesNotUseNmrPrepush,
+          fix: 'Change the check-command in .github/workflows/code-quality.yaml from "pnpm exec nmr prepush" to "pnpm exec nmr ci", which runs the same checks without the audit that audit.yaml already runs'
+        },
+        // -- Legacy script runner ------------------------------------------------
+        {
+          name: "scripts/run-workspace-script.ts does not exist",
+          severity: "error",
+          check: () => !fileExists("scripts/run-workspace-script.ts"),
+          fix: "Delete scripts/run-workspace-script.ts \u2014 nmr replaces this custom script runner"
+        },
+        {
+          name: 'no workspace packages reference run-workspace-script or "pnpm run ws"',
+          severity: "error",
+          check: noWorkspaceRunScriptReferences,
+          fix: 'Remove "ws" script entries and replace any "pnpm run ws" invocations with nmr in each packages/*/package.json'
+        }
+      ]
+    }
+  ]
+});
+var SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([".git", "coverage", "dist", "node_modules"]);
+var CONFIG_EXTENSIONS = "{ts,mts,cts,js,mjs,cjs}";
+var SHARED_VITEST_MODULE = "@williamthorsen/nmr/vitest";
+var SHARED_PRETTIER_MODULE = "@williamthorsen/nmr/prettier";
+var INERT_PRETTIER_CONFIGS = [".prettierrc", ".prettierrc.{json,json5,yaml,yml,toml}"];
+var RE_EXPORT_LINE_PATTERN = /^export\s*(?:\{\s*default\s*\}|\*)\s*from\s*['"]\.\.\/[^'"]*['"];?$/;
+function allWorkspacePackagesCanBuild() {
+  const packagesDir = join(process.cwd(), "packages");
+  if (!existsSync(packagesDir)) return true;
+  const entries = readdirSync2(packagesDir, { withFileTypes: true });
+  const failing = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const pkgPath = `packages/${entry.name}/package.json`;
+    const content = readFile(pkgPath);
+    if (!content) continue;
+    const hasBuildOverride = /"build"\s*:/.test(content);
+    const hasDefaultBuildInputs = fileExists(`packages/${entry.name}/tsconfig.json`) && existsSync(join(packagesDir, entry.name, "src"));
+    if (!hasBuildOverride && !hasDefaultBuildInputs) {
+      failing.push(entry.name);
+    }
+  }
+  if (failing.length === 0) return true;
+  return {
+    ok: false,
+    detail: `missing build override or tsconfig.json + src/: ${failing.join(", ")}`
+  };
+}
+function checkNoMatchingFiles(patterns, cwd) {
+  const found = findFiles(patterns, cwd);
+  if (found.length === 0) return true;
+  return { ok: false, detail: formatPaths(found) };
+}
+function checkRootVitestConfig(baseName, exportName, cwd) {
+  const matches = findFiles([`${baseName}.${CONFIG_EXTENSIONS}`], cwd);
+  if (matches.length === 0) {
+    return { ok: false, detail: `${baseName}.ts is missing` };
+  }
+  const stale = matches.filter(
+    (relativePath) => !importsSharedExport(readFileIn(cwd, relativePath), exportName, SHARED_VITEST_MODULE)
+  );
+  if (stale.length === 0) return true;
+  return { ok: false, detail: `does not import ${exportName} from ${SHARED_VITEST_MODULE}: ${stale.join(", ")}` };
+}
+function prettierConfigBuildsOnSharedConfig(cwd = process.cwd()) {
+  const configs = findFiles(
+    [`.prettierrc.${CONFIG_EXTENSIONS}`, `prettier.config.${CONFIG_EXTENSIONS}`],
+    //
+    cwd
+  );
+  if (configs.length === 0) {
+    return { ok: false, detail: describeMissingPrettierConfig(cwd) };
+  }
+  const stale = configs.filter(
+    (relativePath) => !importsSharedExport(readFileIn(cwd, relativePath), "definePrettierConfig", SHARED_PRETTIER_MODULE)
+  );
+  if (stale.length === 0) return true;
+  return {
+    ok: false,
+    detail: `does not import definePrettierConfig from ${SHARED_PRETTIER_MODULE}: ${stale.join(", ")}`
+  };
+}
+function describeMissingPrettierConfig(cwd) {
+  const inert = findFiles(INERT_PRETTIER_CONFIGS, cwd);
+  if (inert.length > 0) return `holds no code to call the factory: ${inert.join(", ")}`;
+  if (hasPrettierConfigKey(cwd)) {
+    return 'holds no code to call the factory: the "prettier" key in package.json';
+  }
+  return ".prettierrc.js is missing";
+}
+function hasPrettierConfigKey(cwd) {
+  const manifest = readFileIn(cwd, "package.json");
+  if (manifest === void 0) return false;
+  try {
+    const parsed = JSON.parse(manifest);
+    return isRecord(parsed) && parsed.prettier !== void 0;
+  } catch {
+    return false;
+  }
+}
+function codeQualityWorkflowDoesNotUseNmrPrepush() {
+  const content = readFile(".github/workflows/code-quality.yaml");
+  if (content === void 0) return true;
+  return !/check-command:\s*pnpm exec nmr prepush(\s|$)/.test(content);
+}
+function everyTestFileNamesItsTier(cwd = process.cwd()) {
+  const untiered = findTestFiles(cwd).filter((path2) => !hasTierInfix(path2));
+  if (untiered.length === 0) return true;
+  return { ok: false, detail: formatPaths(untiered) };
+}
+function findFiles(patterns, cwd) {
+  return globSync(patterns, { cwd, exclude: (path2) => SCAN_EXCLUDE_DIRS.has(basename(path2)) }).map((path2) => path2.split(sep).join("/")).toSorted();
+}
+function formatPaths(paths) {
+  return `${paths.length} found:
+${paths.map((path2) => `      ${path2}`).join("\n")}`;
+}
+function getMinVersion() {
+  const picked = { "version": "0.26.0" };
+  if (typeof picked.version !== "string") {
+    throw new TypeError("nmr/package.json: 'version' must be a string");
+  }
+  return picked.version;
+}
+function importsSharedExport(content, exportName, moduleSpecifier) {
+  if (content === void 0) return false;
+  const pattern = new RegExp(String.raw`import\s*\{[^}]*\b${exportName}\b[^}]*\}\s*from\s*['"]${moduleSpecifier}['"]`);
+  return pattern.test(content);
+}
+function isReExportOnly(content) {
+  if (content === void 0) return false;
+  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 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)));
+  if (reExports.length === 0) return true;
+  return { ok: false, detail: formatPaths(reExports) };
+}
+function noRedundantRootScripts() {
+  const pkg = readPackageJson();
+  if (!pkg) return true;
+  const scripts = pkg.scripts;
+  if (!isRecord(scripts)) return true;
+  const builtInNames = Object.keys(getDefaultRootScripts());
+  const redundant = Object.keys(scripts).filter((name) => builtInNames.includes(name));
+  if (redundant.length === 0) return true;
+  return {
+    ok: false,
+    detail: `redundant: ${redundant.join(", ")}`
+  };
+}
+function noRetiredVitestConfigs(cwd = process.cwd()) {
+  return checkNoMatchingFiles(
+    [`**/vitest.standalone.config.${CONFIG_EXTENSIONS}`, `**/vitest.integration.config.${CONFIG_EXTENSIONS}`],
+    cwd
+  );
+}
+function noWorkspaceRunScriptReferences() {
+  const packagesDir = join(process.cwd(), "packages");
+  if (!existsSync(packagesDir)) return true;
+  const legacyPattern = /run-workspace-script|"pnpm\s+run\s+ws\b/;
+  const entries = readdirSync2(packagesDir, { withFileTypes: true });
+  const matches = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const content = readFile(`packages/${entry.name}/package.json`);
+    if (content && legacyPattern.test(content)) {
+      matches.push(entry.name);
+    }
+  }
+  if (matches.length === 0) return true;
+  return {
+    ok: false,
+    detail: `found in: ${matches.join(", ")}`
+  };
+}
+function readFileIn(cwd, relativePath) {
+  try {
+    return readFileSync(join(cwd, relativePath), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function scriptExists(name) {
+  const pkg = readPackageJson();
+  if (!pkg) return false;
+  const scripts = pkg.scripts;
+  return isRecord(scripts) && name in scripts;
+}
+function scriptMatches(name, pattern) {
+  const pkg = readPackageJson();
+  if (!pkg) return false;
+  const scripts = pkg.scripts;
+  if (!isRecord(scripts)) return false;
+  const value = scripts[name];
+  return typeof value === "string" && pattern.test(value);
+}
+function toolVersionsHasNoPnpm() {
+  const content = readFile(".tool-versions");
+  if (content === void 0) return true;
+  return !/^pnpm\s/m.test(content);
+}
+function vitestConfigBuildsOnSharedConfig(cwd = process.cwd()) {
+  return checkRootVitestConfig("vitest.config", "defineVitestConfig", cwd);
+}
+function vitestRootConfigBuildsOnSharedConfig(cwd = process.cwd()) {
+  return checkRootVitestConfig("vitest.root.config", "defineRootVitestConfig", cwd);
+}
+export {
+  codeQualityWorkflowDoesNotUseNmrPrepush,
+  default_default as default,
+  everyTestFileNamesItsTier,
+  noReExportOnlyVitestConfigs,
+  noRetiredVitestConfigs,
+  prettierConfigBuildsOnSharedConfig,
+  vitestConfigBuildsOnSharedConfig,
+  vitestRootConfigBuildsOnSharedConfig
+};

package/.readyup/manifest.json

@@ -0,0 +1,16 @@
+{
+  "version": 1,
+  "kits": [
+    {
+      "checklists": [
+        "nmr"
+      ],
+      "name": "default",
+      "path": "kits/default.js",
+      "readyupVersion": "0.23.0",
+      "source": "kits/default.ts",
+      "sourceHash": "f646e7fb",
+      "targetHash": "56564046"
+    }
+  ]
+}

package/README.md

@@ -3,47 +3,21 @@
 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.24.0 (2026-08-03)
+## Release notes — v0.26.0 (2026-08-04)
 
 ### 🎉 Features
 
-- 🚨 **Breaking:** Retire integration label in favor of an isolation-tier test ladder (#552)
+- Publish each package's readyup kit from the package that owns it (#590)
 
-  Test groups are now named for what a test reaches rather than for how much of the codebase it covers: `integration` and `app` are replaced by `unit`, `tool`, `localhost`, and `remote`.
+  ReadyUp checks for `@williamthorsen/nmr`, `@williamthorsen/release-kit`, and `v11y-check` are now run directly against these packages, guaranteeing a version-appropriate check, instead of against their host repo. The package must be installed as a direct dependency in the calling repo.
 
-  `nmr test` now runs the `tool` group alongside `unit`, so the first run after upgrading may fail on tests that nothing was running before. Upgrading means renaming `*.int.test.ts` files onto the new groups and replacing `nmr test:integration` with `nmr test:tool`.
+  The syntax is `rdy run --from npm:<package>`. `rdy run --packages` runs the kits contained in any packages listed in `.config/readyup.config.ts`. Requires `readyup` 0.23 or later.
 
-- Let Vitest config files compose shared options and target one tier (#556)
+- Ship agent guidance as CodeAssembly package content (#591)
 
-  Vitest settings can now be shared across config files: A repo declares its common options once, and a workspace can use its own config file to supplement or override them. Shared setup files run first. An option can now target a single test tier instead of all tiers, allowing per-tier timeouts to be set.
+  A repo that consumes `@williamthorsen/nmr` can now adopt `nmr`'s agent guidance by naming the package in `.agents/codeassembly.yaml`. `codeassembly sync` then delivers that guidance to every agent harness. Guidance updates are thus delivered directly with each package, eliminating the need to keep a guidance file in sync. The `nmr sync-agent-files` command has been removed.
 
-- 🚨 **Breaking:** Redefine ci as the code-quality gate and add prepush (#559)
-
-  Repurposes the `nmr ci` command to align with its name; it now runs the code-quality checks that run in CI: `nmr build && nmr check:strict`. A new `nmr prepush` command, combining code-quality checks and the security audit, takes the place of `nmr ci`. nmr's readyup kit is adjusted to account for the changes.
-
-- Exclude test scaffolding from builds and make the ignore set configurable (#564)
-
-  The `build` command now ignores the directories typically used for test scaffolding, such as fixtures and mocks. The exclusion includes `test-utils/`, which is treated as the conventional name for a directory containing test utilities. A package can declare additional ignore patterns in its config file.
-
-- Skip checks that already passed on the current working tree (#568)
-
-  `nmr` commands now skip any pure check (types, lint, tests) that has already passed on an unchanged working tree; instead, success is reported immediately. `nmr --no-cache` causes the cache check to be skipped, and `NMR_NO_CACHE=1` does the same for a whole shell. Cached results are cleared by `nmr clean`. Which commands can skip is configurable at the monorepo root, and `NMR_DEBUG=1` reports why a run didn't skip.
-
-### 🪦 Removed
-
-- 🚨 **Breaking:** Remove the package root entry in favor of /config (#569)
-
-  `defineConfig` is now imported from `@williamthorsen/nmr/config` instead of the bare package.
-
-### 🐛 Bug fixes
-
-- Stop excluding *.types.ts and mock* files from coverage
-
-  Coverage now measures modules matching `*.types.ts` and `mock*`, which the shared Vitest config previously excluded. A type module that grows a type guard, or a mock helper placed in `test-utils/` where helpers are meant to stay measured, was left out of the report with nothing saying so, and because exclusions concatenate, no consuming repo could add it back.
-
-  What remains excluded names something that cannot hold runtime code by construction: a directory of test scaffolding, a barrel, and a declaration file. A pattern resting on a filename alone suppresses nothing it could claim to, since a file with no executable statements is absent from the report either way.
-
-  A repo enforcing its own coverage thresholds may see a lower figure once these files enter the denominator.
+  Migration guide: Delete `.agents/nmr/`, remove the `@nmr/AGENTS.md` include line, and remove all uses of `check:agent-files`.
 <!-- /section:release-notes -->
 
 ## Installation
@@ -228,23 +202,23 @@ import { defineConfig } from '@williamthorsen/nmr/config';
 
 export default defineConfig({
   workspaceScripts: {
-    'build:pre': 'npx rdy compile',
+    'build:pre': 'node scripts/generate-manifest.ts',
   },
 });
 ```
 
-Attach a post-build step to one package:
+Attach a step to one package's hook:
 
 ```jsonc
-// packages/nmr/package.json
+// packages/my-package/package.json
 {
   "scripts": {
-    "build:post": "nmr-sync-agent-files",
+    "upgrade:post": "nmr-report-overrides",
   },
 }
 ```
 
-The second example calls the bin directly, which sidesteps the workspace-versus-root registry distinction.
+The second example calls the bin directly: `report-overrides` is a root-registry command, so `nmr report-overrides` from inside a package fails with `Unknown command`, while the bin runs from either scope.
 
 ## Check-result cache
 
@@ -255,7 +229,7 @@ $ nmr ci
 # ... four minutes of build, typecheck, lint, and coverage ...
 
 $ nmr ci
-⏭️ ci: passed 2m ago on this tree (saved ~4m). Re-run with --no-cache.
+⏭️ ci: passed 2m ago on this tree (🚀 saved ~4m). Re-run with --no-cache.
 ```
 
 Composite commands expand into child `nmr` processes, so one green `nmr ci` records a pass for every cacheable command in the chain, at every scope it ran at. A later `nmr check`, `nmr typecheck`, or `nmr -F core test` on the same tree skips too. The skip line is suppressed by `-q`.
@@ -264,7 +238,7 @@ The cache is a working-tree cache, not a build cache: it answers "has this exact
 
 ### What is cached
 
-Cacheable by default: `check`, `check:agent-files`, `check:strict`, `ci`, `fix:check`, `fmt:check`, `lint:check`, `lint:strict`, `test`, `test:coverage`, `test:tool`, `test:unit`, `typecheck`, and the `root:` variants `root:check`, `root:lint:check`, `root:lint:strict`, `root:test`, `root:test:tool`, `root:test:unit`, and `root:typecheck`.
+Cacheable by default: `check`, `check:strict`, `ci`, `fix:check`, `fmt:check`, `lint:check`, `lint:strict`, `test`, `test:coverage`, `test:tool`, `test:unit`, `typecheck`, and the `root:` variants `root:check`, `root:lint:check`, `root:lint:strict`, `root:test`, `root:test:tool`, `root:test:unit`, and `root:typecheck`.
 
 Everything else runs every time:
 
@@ -464,11 +438,10 @@ Neither is bound to a git hook. `prepush` is named for when you run it, not for
 
 #### Check and quality
 
-| Command             | Runs                                                                          |
-| ------------------- | ----------------------------------------------------------------------------- |
-| `check`             | `typecheck`, `fmt:check`, `lint:check`, `test`                                |
-| `check:agent-files` | `nmr-sync-agent-files --check`                                                |
-| `check:strict`      | `typecheck`, `fmt:check`, `lint:strict`, `test:coverage`, `check:agent-files` |
+| Command        | Runs                                                     |
+| -------------- | -------------------------------------------------------- |
+| `check`        | `typecheck`, `fmt:check`, `lint:check`, `test`           |
+| `check:strict` | `typecheck`, `fmt:check`, `lint:strict`, `test:coverage` |
 
 #### Fix
 
@@ -558,7 +531,6 @@ These scripts operate on root-level code only (not workspace packages):
 | Command            | Runs                   |
 | ------------------ | ---------------------- |
 | `report-overrides` | `nmr-report-overrides` |
-| `sync-agent-files` | `nmr-sync-agent-files` |
 
 ## CLI reference
 
@@ -612,35 +584,33 @@ Report any active `pnpm.overrides` in the root `package.json`, reminding develop
 nmr report-overrides
 ```
 
-### `sync-agent-files`
+## Agent guidance
 
-Sync the agent-facing guidance shipped with nmr into the consuming repo.
+nmr ships the rules an agent needs in order to invoke it, as [CodeAssembly](https://github.com/williamthorsen/codeassembly) package content. Adopt it by naming the package in the consuming repo's `.agents/codeassembly.yaml`:
 
-```bash
-nmr sync-agent-files         # write .agents/nmr/AGENTS.md, stamped with the installed nmr version
-nmr sync-agent-files --check # verify the stamp matches; exit 1 with a fix message if not
+```yaml
+packages:
+  use:
+    - '@williamthorsen/nmr'
 ```
 
-Run `nmr sync-agent-files` once after upgrading nmr. The generated file is committed to the consuming repo; do not edit it by hand.
-
-The default root `check:strict` composite includes `check:agent-files`, which runs `--check` automatically — so any CI pipeline already running `check:strict` catches drift without per-consumer wiring.
+Then add `codeassembly` as a devDependency and run `codeassembly sync`. The guidance is injected into the machine-local guidance file each harness loads at launch; nothing is copied into the repo or committed there. It resolves from the installed package, so upgrading nmr updates it with no second step.
 
-To expose the synced guidance to Claude Code sessions, add this include to the consuming repo's `.agents/PROJECT.md`:
+Wiring the sync to `postinstall` keeps it current without a hand-run command:
 
-```markdown
-@nmr/AGENTS.md
+```json
+{
+  "scripts": {
+    "postinstall": "codeassembly sync --warn-only"
+  }
+}
 ```
 
-#### What belongs in the synced file
-
-The synced file is injected at launch in every consuming repo, so every line is paid for on every task whether or not it is relevant. It is a cheatsheet, not a manual.
+`--warn-only` reports a sync failure and exits 0; without it, a failed sync aborts `pnpm install`.
 
-A line earns a place in `AGENTS.md` only if both hold:
+### Migrating from `sync-agent-files`
 
-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 this README, reachable on demand at `node_modules/@williamthorsen/nmr/README.md`, with a pointer from `AGENTS.md` naming the topic so an agent knows to look. When adding a feature, document it here and extend that pointer rather than the cheatsheet.
+The `nmr sync-agent-files` command, its `nmr-sync-agent-files` bin, and the `check:agent-files` script were removed in favor of the above. After upgrading, delete the generated `.agents/nmr/` directory and the `@nmr/AGENTS.md` line it was exposed through, drop `check:agent-files` from any `check:strict` override that enumerates it, and remove any direct call to the bin.
 
 ## Standalone utilities
 
@@ -707,6 +677,29 @@ ensure-prepublish-hooks
 | `--dry-run`           | Preview what `--fix` would do | —                 |
 | `--command <command>` | Custom hook command           | `"npm run build"` |
 
+## 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.
+
+Add `readyup` as a devDependency, then name nmr in its config:
+
+```ts
+// .config/readyup.config.ts
+import { defineRdyConfig } from 'readyup';
+
+export default defineRdyConfig({
+  packages: ['@williamthorsen/nmr'],
+});
+```
+
+```bash
+rdy run --packages                       # every kit each listed package publishes
+rdy run --from npm:@williamthorsen/nmr   # nmr's kit alone, without the config entry
+rdy list --from npm:@williamthorsen/nmr  # what nmr publishes
+```
+
+`--packages` is the form that survives nmr publishing further kits. Both need `readyup` 0.23 or later, and `@williamthorsen/nmr` as a _direct_ devDependency: a strict pnpm layout links nothing else into the project, so a transitive copy is unreachable.
+
 ## Consumer migration
 
 After installing, a consuming repo's root `package.json` scripts shrink to lifecycle hooks:
@@ -833,7 +826,9 @@ vitest                               # every project
 
 **A tier is not a statement about preconditions.** A `unit` test may still need something set up before it runs: a build, a generated fixture, a seeded file. What makes it `unit` is that it reaches nothing beyond the test process _while running_. The filesystem sits in `unit` for the same reason the tiers exist: they gate on what must be available, and the filesystem always is.
 
-`unit` is defined by subtracting the tiers rather than by an allow-list of infixes, so a file such as `parser.smoke.test.ts` runs under `unit` instead of being silently dropped. That is also what makes an unrecognized infix safe to use as documentation: `resolveConfig.packaged.test.ts` runs under `unit` and reads as a companion to `resolveConfig.unit.test.ts`.
+**Every test file names its tier**, in the form `<subject>[.<aspect>].<tier>.test.ts`. Only the segment immediately before `.test.` selects a project, so an earlier one is free for documentation: `resolveConfig.packaged.unit.test.ts` reads as a companion to `resolveConfig.unit.test.ts` and still names `unit`.
+
+`unit` is defined by subtracting the tiers rather than by an allow-list of infixes, so a file such as `parser.smoke.test.ts` runs under `unit` instead of being silently dropped. That is a safety net, not a licence to omit the tier: a file whose tier segment is missing or misspelt runs under `unit` and reports success, so no test run distinguishes it from a conformant one. [nmr's readyup kit](#conformance-checks) reports those files, which is the only thing that does.
 
 `localhost` and `remote` have no test script of their own. They are declared anyway, so that a `*.remote.test.ts` file cannot fall into `unit` and run in the default gate unnoticed.
 
@@ -934,11 +929,11 @@ This variant reads `pnpm-workspace.yaml` and excludes every workspace package fr
 
 The projects were once named `unit`, `integration`, and `app`, for what a test _covered_ rather than what it _reached_. `integration` and `app` are gone.
 
-1. Rename every `*.int.test.ts`. A test that reaches a program the environment supplies becomes `*.tool.test.ts`; one that reaches nothing beyond the test process drops the infix. Re-read each file rather than renaming in bulk -- the axis changed, so the old bucket does not map onto one new tier.
-2. Leave `*.app.test.ts` alone, or rename at your leisure. `app` was never a tier, and its files now land in `unit`.
+1. Rename every `*.int.test.ts`. A test that reaches a program the environment supplies becomes `*.tool.test.ts`; one that reaches nothing beyond the test process becomes `*.unit.test.ts`. Re-read each file rather than renaming in bulk -- the axis changed, so the old bucket does not map onto one new tier.
+2. Rename every `*.app.test.ts` onto the convention. `app` was never a tier, so keep it as the aspect segment and add the tier after it: `scaffold.app.test.ts` becomes `scaffold.app.unit.test.ts`.
 3. Replace `nmr test:integration` with `nmr test:tool`, and `nmr root:test:integration` with `nmr root:test:tool`, wherever a script or workflow names them.
 
-**An unrenamed `*.int.test.ts` file is a silent failure.** `.int.` no longer matches a project, so the residual `unit` claims those files and they run in the default gate -- green, with nothing reporting that the separation was lost. `rdy run nmr` reports them; a passing test run does not. Run it before treating the migration as done.
+**A file left without a tier is a silent failure.** The residual `unit` claims it and it runs in the default gate -- green, with nothing reporting that the separation was lost. [nmr's readyup kit](#conformance-checks) reports every such file; a passing test run does not. Run it before treating the migration as done.
 
 `nmr test` also runs the `tool` tier, which the old `test` excluded. Those tests previously ran in no default selection at all: `check`, `check:strict`, and `ci` all inherited the exclusion, so a green pipeline said nothing about them. Expect `nmr test` to take longer and to surface failures that were never gated.
 

package/agents/README.md

@@ -0,0 +1,24 @@
+# Authoring nmr's agent guidance
+
+This directory is a CodeAssembly content root, declared by the `codeassembly.content` key in `packages/nmr/package.json`.
+
+## The ambient cheatsheet
+
+`guidance/rulebooks/nmr.md` carries `delivery: ambient`, so its body is injected at launch in every consuming repo. Every line is paid for on every task, whether or not it is relevant. It is a cheatsheet, not a manual.
+
+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.
+
+## Constraints on rulebook bodies
+
+Rulebook bodies carry no links to other rulebooks. CodeAssembly's renderer rewrites link targets under `skills/` and `scripts/` and rejects everything else, so a cross-reference names the deployed `consult-<slug>` in prose and declares the edge under `dependencies:`.
+
+Anchor-only links are checked against the body they appear in, so a fragment naming a heading that lives in another document fails the run. Check `](#` before moving a section between bodies.
+
+## Publishing
+
+The directory is published because `files` in `packages/nmr/package.json` lists it. Dropping that entry fails nothing locally, because this repo resolves the guidance through a `workspace:*` self-link that `files` does not govern. `packaging.tool.test.ts` is what catches it.

package/{AGENTS.md → agents/guidance/rulebooks/nmr.md}

@@ -1,8 +1,10 @@
 ---
-source: '@williamthorsen/nmr@0.0.0-source'
+slug: nmr
+description: Invocation rules for the nmr script runner in a pnpm monorepo.
+delivery: ambient
 ---
 
-# nmr: agent guidance (generated; do not edit)
+# nmr: agent guidance
 
 - Use `nmr <command>`, not `pnpm run <command>`, for anything nmr provides. Run bare `nmr` to list every command and the shell command it resolves to; a wrong guess reports only `Unknown command`, with no list.
 - 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.

package/dist/esm/check-cache.js

@@ -5,6 +5,7 @@ import process from 'node:process';
 import { hashWorkingTree, readHeadSha, readJsonCacheEntry, removeCacheDir, resolveCacheEntryPath, writeCacheEntry, } from '@williamthorsen/nmr-core';
 import { hasBuildOutput, readBuildDigest } from "./commands/build-output.js";
 import { loadWorkspaceConfig } from "./config.js";
+import { formatDuration, formatSaving } from "./helpers/duration.js";
 import { isObject, isStringRecord } from "./helpers/type-guards.js";
 import { getDefaultWorkspaceScripts } from "./resolve-scripts.js";
 import { buildWorkspaceRegistry, resolveScript } from "./resolver.js";
@@ -17,7 +18,6 @@ export const CURRENT_RUNTIME = {
 export const DEBUG_ENV_VAR = 'NMR_DEBUG';
 export const DEFAULT_CACHEABLE_COMMANDS = [
     'check',
-    'check:agent-files',
     'check:strict',
     'ci',
     'fix:check',
@@ -91,8 +91,9 @@ export function formatMisplacedNoCacheWarning(command) {
 }
 export function formatSkipLine(command, entry, now) {
     const age = formatDuration(Math.max(0, now - Date.parse(entry.recordedAt)));
-    const saved = formatDuration(entry.durationMs);
-    return `⏭️ ${command}: passed ${age} ago on this tree (saved ~${saved}). Re-run with --no-cache.`;
+    const saving = formatSaving(entry.durationMs);
+    const savingClause = saving === undefined ? '' : ` (${saving})`;
+    return `⏭️ ${command}: passed ${age} ago on this tree${savingClause}. Re-run with --no-cache.`;
 }
 export async function readBuildOutputState(monorepoRoot, config) {
     const state = { missing: [], digests: {} };
@@ -165,9 +166,6 @@ export function writeDebugNote(message, env, stderr) {
         stderr.write(`nmr check-cache: ${message}\n`);
     }
 }
-const MILLISECONDS_PER_SECOND = 1000;
-const SECONDS_PER_MINUTE = 60;
-const MINUTES_PER_HOUR = 60;
 function decodeTreeSnapshot(encoded) {
     if (encoded === undefined) {
         return undefined;
@@ -178,17 +176,6 @@ function decodeTreeSnapshot(encoded) {
     }
     return { hash, headSha };
 }
-function formatDuration(milliseconds) {
-    const seconds = Math.round(milliseconds / MILLISECONDS_PER_SECOND);
-    if (seconds < SECONDS_PER_MINUTE) {
-        return `${seconds}s`;
-    }
-    const minutes = Math.round(seconds / SECONDS_PER_MINUTE);
-    if (minutes < MINUTES_PER_HOUR) {
-        return `${minutes}m`;
-    }
-    return `${Math.round(minutes / MINUTES_PER_HOUR)}h`;
-}
 function isCheckCacheEntry(value) {
     if (!isObject(value)) {
         return false;

package/dist/esm/default-scripts.js

@@ -28,8 +28,7 @@ export const rootScripts = {
     'audit:prod': 'pnpm exec v11y --prod',
     build: 'pnpm --recursive exec nmr build',
     check: ['typecheck', 'fmt:check', 'lint:check', 'test'],
-    'check:agent-files': 'nmr-sync-agent-files --check',
-    'check:strict': ['typecheck', 'fmt:check', 'lint:strict', 'test:coverage', 'check:agent-files'],
+    'check:strict': ['typecheck', 'fmt:check', 'lint:strict', 'test:coverage'],
     ci: ['build', 'check:strict'],
     clean: 'nmr-clean',
     fix: ['lint', 'fmt'],
@@ -51,7 +50,6 @@ export const rootScripts = {
     'root:test:unit': 'vitest --config ./vitest.root.config.ts --project unit',
     'root:typecheck': 'tsgo --noEmit',
     'root:upgrade': 'nmr-taze --include-locked',
-    'sync-agent-files': 'nmr-sync-agent-files',
     test: 'nmr root:test && pnpm --recursive exec nmr test',
     'test:all': 'nmr root:test:all && pnpm --recursive exec nmr test:all',
     'test:coverage': 'nmr root:test && pnpm --recursive exec nmr test:coverage',

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

@@ -0,0 +1,2 @@
+export declare function formatDuration(milliseconds: number): string;
+export declare function formatSaving(milliseconds: number): string | undefined;

package/dist/esm/helpers/duration.js

@@ -0,0 +1,21 @@
+export function formatDuration(milliseconds) {
+    const seconds = Math.round(milliseconds / MILLISECONDS_PER_SECOND);
+    if (seconds < SECONDS_PER_MINUTE) {
+        return `${seconds}s`;
+    }
+    const minutes = Math.round(seconds / SECONDS_PER_MINUTE);
+    if (minutes < MINUTES_PER_HOUR) {
+        return `${minutes}m`;
+    }
+    return `${Math.round(minutes / MINUTES_PER_HOUR)}h`;
+}
+export function formatSaving(milliseconds) {
+    if (!Number.isFinite(milliseconds) || milliseconds < MILLISECONDS_PER_SECOND) {
+        return undefined;
+    }
+    return `${SPEED_BOOST_ICON} saved ~${formatDuration(milliseconds)}`;
+}
+const MILLISECONDS_PER_SECOND = 1000;
+const MINUTES_PER_HOUR = 60;
+const SECONDS_PER_MINUTE = 60;
+const SPEED_BOOST_ICON = '🚀';

package/dist/esm/tiers.d.ts

@@ -0,0 +1,7 @@
+export declare const ALL_TEST_PATTERNS: string[];
+export declare function buildTierPatterns(tier: string): string[];
+export declare function findTestFiles(rootDir: string): string[];
+export declare function hasTierInfix(filePath: string): boolean;
+export declare const TEST_COLLECTION_EXCLUDE: string[];
+export declare const TIER_NAMES: readonly ["unit", "tool", "localhost", "remote"];
+export type TierName = (typeof TIER_NAMES)[number];

package/dist/esm/tiers.js

@@ -0,0 +1,35 @@
+import { readdirSync } from 'node:fs';
+import path from 'node:path';
+const TEST_DIR = '__tests__';
+const TEST_EXTENSIONS = '{ts,tsx}';
+const TEST_GLOB_PREFIX = `**/${TEST_DIR}/**`;
+const TEST_FILE_PATTERN = /\.test\.tsx?$/;
+export const ALL_TEST_PATTERNS = [`${TEST_GLOB_PREFIX}/*.test.${TEST_EXTENSIONS}`];
+export function buildTierPatterns(tier) {
+    return [`${TEST_GLOB_PREFIX}/*.${tier}.test.${TEST_EXTENSIONS}`];
+}
+export function findTestFiles(rootDir) {
+    const found = [];
+    collectTestFiles(rootDir, '', false, found);
+    return found.toSorted();
+}
+export function hasTierInfix(filePath) {
+    const tiers = TIER_NAMES;
+    return tiers.includes(path.basename(filePath).split('.').at(-3) ?? '');
+}
+export const TEST_COLLECTION_EXCLUDE = ['.git', 'coverage', 'dist', 'node_modules'];
+export const TIER_NAMES = ['unit', 'tool', 'localhost', 'remote'];
+function collectTestFiles(dir, relativeDir, inTestDir, found) {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const relativePath = relativeDir === '' ? entry.name : `${relativeDir}/${entry.name}`;
+        if (entry.isDirectory()) {
+            if (TEST_COLLECTION_EXCLUDE.includes(entry.name))
+                continue;
+            collectTestFiles(path.join(dir, entry.name), relativePath, inTestDir || entry.name === TEST_DIR, found);
+        }
+        else if (inTestDir && TEST_FILE_PATTERN.test(entry.name)) {
+            found.push(relativePath);
+        }
+    }
+}

package/dist/esm/vitest.d.ts

@@ -1,5 +1,7 @@
 import type { ViteUserConfig } from 'vitest/config';
 import type { InlineConfig, ProjectConfig } from 'vitest/node';
+import type { TierName } from './tiers.js';
+export type { TierName } from './tiers.js';
 export type RootTestOptions = Omit<InlineConfig, keyof ProjectConfig>;
 export type RootOverrides = Omit<ViteUserConfig, 'test'> & {
     test?: RootTestOptions;
@@ -13,8 +15,5 @@ export interface RootVitestConfigOptions extends VitestConfigOptions {
     monorepoRoot: string;
 }
 type RootConfigLayers = [...(VitestConfigOptions | undefined)[], RootVitestConfigOptions];
-declare const TIER_NAMES: readonly ["unit", "tool", "localhost", "remote"];
-export type TierName = (typeof TIER_NAMES)[number];
 export declare function defineVitestConfig(...layers: (VitestConfigOptions | undefined)[]): ViteUserConfig;
 export declare function defineRootVitestConfig(...layers: RootConfigLayers): ViteUserConfig;
-export {};

package/dist/esm/vitest.js

@@ -1,14 +1,13 @@
 import path from 'node:path';
 import { defaultExclude, mergeConfig } from 'vitest/config';
 import { isObject } from "./helpers/type-guards.js";
+import { ALL_TEST_PATTERNS, buildTierPatterns, TEST_COLLECTION_EXCLUDE, TIER_NAMES } from "./tiers.js";
 import { getWorkspacePackageDirs } from "./workspace.js";
-const TIER_NAMES = ['unit', 'tool', 'localhost', 'remote'];
 const [RESIDUAL_TIER, ...NAMED_TIERS] = TIER_NAMES;
 const TIERED_PATTERNS = NAMED_TIERS.flatMap(buildTierPatterns);
 const TIER_TIMEOUT = 30_000;
-const ALL_TEST_PATTERNS = ['**/__tests__/**/*.test.{ts,tsx}'];
 const COVERAGE_EXCLUDE = ['**/__{fixtures,mocks,tests}__/**', '**/index.ts', '**/*.d.ts'];
-const BUILD_OUTPUT_EXCLUDE = ['**/dist/**'];
+const COLLECTION_EXCLUDE = [...new Set([...defaultExclude, ...TEST_COLLECTION_EXCLUDE.map((dir) => `**/${dir}/**`)])];
 const PACKAGE_COVERAGE_INCLUDE = ['**/src/**/*.{ts,tsx}'];
 const MISSING_MONOREPO_ROOT = 'defineRootVitestConfig requires `monorepoRoot`, an absolute path to the directory holding pnpm-workspace.yaml. Pass `import.meta.dirname` in the last options layer, from the root config.';
 export function defineVitestConfig(...layers) {
@@ -60,7 +59,7 @@ function buildProjects(layers, extraExclude, projectRoot) {
             extends: true,
             ...(projectRoot !== undefined && { root: projectRoot }),
             test: {
-                exclude: [...defaultExclude, ...BUILD_OUTPUT_EXCLUDE, ...exclude, ...extraExclude],
+                exclude: [...COLLECTION_EXCLUDE, ...exclude, ...extraExclude],
                 include,
                 name,
                 ...(timeout !== undefined && { hookTimeout: timeout, testTimeout: timeout }),
@@ -84,9 +83,6 @@ function assertKnownTiers(layers) {
         }
     }
 }
-function buildTierPatterns(tier) {
-    return [`**/__tests__/**/*.${tier}.test.{ts,tsx}`];
-}
 function getWorkspaceExcludePatterns(monorepoRoot) {
     return getWorkspacePackageDirs(monorepoRoot)
         .map((dir) => `${path.relative(monorepoRoot, dir).split(path.sep).join('/')}/**`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/nmr",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "private": false,
   "description": "Context-aware script runner for pnpm monorepos",
   "keywords": [
@@ -54,11 +54,12 @@
     "nmr-compile": "bin/nmr-compile.js",
     "nmr-fmt": "bin/nmr-fmt.js",
     "nmr-report-overrides": "bin/nmr-report-overrides.js",
-    "nmr-sync-agent-files": "bin/nmr-sync-agent-files.js",
     "nmr-taze": "bin/nmr-taze.js"
   },
   "files": [
-    "AGENTS.md",
+    ".readyup/kits/*.js",
+    ".readyup/manifest.json",
+    "agents",
     "bin",
     "dist"
   ],
@@ -67,10 +68,11 @@
     "prettier-plugin-sh": "0.19.0",
     "taze": "19.16.0",
     "yaml": "2.9.0",
-    "@williamthorsen/nmr-core": "0.8.0"
+    "@williamthorsen/nmr-core": "0.9.0"
   },
   "devDependencies": {
     "prettier": "3.9.6",
+    "readyup": "0.23.0",
     "tinyglobby": "0.2.17",
     "vitest": "4.1.10"
   },
@@ -93,7 +95,11 @@
   "publishConfig": {
     "access": "public"
   },
+  "codeassembly": {
+    "content": "agents"
+  },
   "scripts": {
-    "build:post": "nmr-sync-agent-files"
+    "build:post": "rdy compile",
+    "build:pre": "rdy verify"
   }
 }

package/bin/nmr-sync-agent-files.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-try {
-  await import('../dist/esm/cli-sync-agent-files.js');
-} catch (error) {
-  if (error.code === 'ERR_MODULE_NOT_FOUND') {
-    process.stderr.write('nmr-sync-agent-files: build output not found — run `pnpm run build` first\n');
-  } else {
-    process.stderr.write(`nmr-sync-agent-files: failed to load: ${error.message}\n`);
-  }
-  process.exit(1);
-}

package/dist/esm/cli-sync-agent-files.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/cli-sync-agent-files.js

@@ -1,29 +0,0 @@
-import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
-import { check, sync } from "./commands/sync-agent-files.js";
-import { findMonorepoRoot } from "./workspace.js";
-const flagSchema = {
-    check: { long: '--check', type: 'boolean' },
-};
-const { flags } = parseArgsOrExit(process.argv.slice(2), flagSchema);
-try {
-    runCommand(flags.check);
-}
-catch (error) {
-    reportError(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-}
-function runCommand(checkOnly) {
-    const monorepoRoot = findMonorepoRoot();
-    if (!checkOnly) {
-        const { path: destinationPath, packageSpecifier, changed } = sync(monorepoRoot);
-        console.info(changed ? `✓ Wrote ${destinationPath} (${packageSpecifier})` : `✓ ${destinationPath} already up to date`);
-        process.exit(0);
-    }
-    const result = check(monorepoRoot);
-    if (result.ok) {
-        console.info('✓ .agents/nmr/AGENTS.md is in sync');
-        process.exit(0);
-    }
-    process.stderr.write(`${result.reason}\n`);
-    process.exit(1);
-}

package/dist/esm/commands/sync-agent-files.d.ts

@@ -1,13 +0,0 @@
-export declare function check(destinationDir: string): CheckResult;
-export interface SyncResult {
-    path: string;
-    packageSpecifier: string;
-    changed: boolean;
-}
-export declare function sync(destinationDir: string): SyncResult;
-export type CheckResult = {
-    ok: true;
-} | {
-    ok: false;
-    reason: string;
-};

package/dist/esm/commands/sync-agent-files.js

@@ -1,58 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { readPackageVersion } from '@williamthorsen/nmr-core';
-const VERSION = readPackageVersion(import.meta.url);
-const PACKAGE_NAME = '@williamthorsen/nmr';
-const DESTINATION_RELATIVE_PATH = '.agents/nmr/AGENTS.md';
-const SOURCE_FILENAME = 'AGENTS.md';
-const FRONTMATTER_REGEX = /^---\n((?:.*\n)*?)---\n/;
-export function check(destinationDir) {
-    const destinationPath = getDestinationPath(destinationDir);
-    if (!existsSync(destinationPath)) {
-        return {
-            ok: false,
-            reason: `${DESTINATION_RELATIVE_PATH} is missing. Run \`nmr sync-agent-files\`.`,
-        };
-    }
-    const expectedBody = stripFrontmatter(readFileSync(getSourcePath(), 'utf8'));
-    const foundBody = stripFrontmatter(readFileSync(destinationPath, 'utf8'));
-    if (foundBody !== expectedBody) {
-        return {
-            ok: false,
-            reason: `${DESTINATION_RELATIVE_PATH} content is out of date. Run \`nmr sync-agent-files\`.`,
-        };
-    }
-    return { ok: true };
-}
-export function sync(destinationDir) {
-    const body = stripFrontmatter(readFileSync(getSourcePath(), 'utf8'));
-    const packageSpecifier = buildPackageSpecifier();
-    const destinationPath = getDestinationPath(destinationDir);
-    if (existsSync(destinationPath) && stripFrontmatter(readFileSync(destinationPath, 'utf8')) === body) {
-        return { path: destinationPath, packageSpecifier, changed: false };
-    }
-    const output = `---\nsource: '${packageSpecifier}'\n---\n${body}`;
-    mkdirSync(path.dirname(destinationPath), { recursive: true });
-    writeFileSync(destinationPath, output, 'utf8');
-    return { path: destinationPath, packageSpecifier, changed: true };
-}
-function buildPackageSpecifier() {
-    return `${PACKAGE_NAME}@${VERSION}`;
-}
-function getDestinationPath(destinationDir) {
-    return path.join(destinationDir, DESTINATION_RELATIVE_PATH);
-}
-function getSourcePath() {
-    let dir = path.dirname(fileURLToPath(import.meta.url));
-    while (dir !== path.dirname(dir)) {
-        const candidate = path.join(dir, SOURCE_FILENAME);
-        if (existsSync(candidate))
-            return candidate;
-        dir = path.dirname(dir);
-    }
-    throw new Error(`Could not locate ${SOURCE_FILENAME} in any parent of ${fileURLToPath(import.meta.url)}`);
-}
-function stripFrontmatter(content) {
-    return content.replace(FRONTMATTER_REGEX, '');
-}