@hublo/sentinel 1.4.0-alpha.2 → 1.4.0-alpha.20

package/dist/{chunk-4UIZJ3TR.js → chunk-BPLSUYU7.js}

@@ -5,7 +5,7 @@ import {
   readNxProjectName,
   readOwnPackage,
   readProjectPackageJson
-} from "./chunk-WLFE5RUU.js";
+} from "./chunk-NW6UHNYX.js";
 
 // src/core/registry.ts
 var adapters = [];
@@ -109,7 +109,7 @@ var SWEEPABLE_TARGETS = TARGETS.filter(
 var PRESET_NAMES = ["react", "nest", "svelte", "node", "tools"];
 
 // src/shared/color.ts
-import { styleText } from "util";
+import { styleText } from "node:util";
 function palette(stream) {
   const paint = (format, text) => styleText(format, text, { stream });
   return {
@@ -123,8 +123,8 @@ function palette(stream) {
 }
 
 // src/roles/build/nest/nx-target.ts
-import { existsSync, readFileSync } from "fs";
-import { join, relative } from "path";
+import { existsSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
 var DEPRECATED_NX_BUILDER = "@nx/webpack:webpack";
 var TRANSLATABLE_WEBPACK_CONFIG = "tools/webpack-configs/update.webpack.config.js";
 var readProjectJson = (cwd) => {
@@ -195,8 +195,8 @@ function workspaceRootHops(cwd, target) {
 }
 
 // src/roles/build/read-adoption.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { join as join4 } from "node:path";
 
 // src/core/config/module-type.ts
 function esmReadiness(fileName, packageType) {
@@ -210,8 +210,8 @@ function esmReadiness(fileName, packageType) {
 }
 
 // src/core/config/manifest.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { basename, join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { basename, join as join2 } from "node:path";
 function moduleScripts(cwd) {
   try {
     const pkg = JSON.parse(readFileSync2(join2(cwd, "package.json"), "utf8"));
@@ -220,6 +220,14 @@ function moduleScripts(cwd) {
     return {};
   }
 }
+function manifestTargets(cwd) {
+  try {
+    const pkg = JSON.parse(readFileSync2(join2(cwd, "package.json"), "utf8"));
+    return pkg.nx?.targets ?? {};
+  } catch {
+    return {};
+  }
+}
 function moduleName2(cwd) {
   try {
     const pkg = JSON.parse(readFileSync2(join2(cwd, "package.json"), "utf8"));
@@ -256,8 +264,8 @@ function manifestOperation(cwd, scripts) {
 }
 
 // src/core/config/project-json.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
 function projectTargets(cwd) {
   const path = join3(cwd, "project.json");
   if (!existsSync3(path)) return void 0;
@@ -514,11 +522,11 @@ function readBuildAdoption(cwd) {
 }
 
 // src/roles/build/adapters/vite/vite-role.adapter.ts
-import { spawnSync } from "child_process";
+import { spawnSync } from "node:child_process";
 
 // src/core/config/tool-args.ts
-import { existsSync as existsSync5 } from "fs";
-import { isAbsolute, resolve as resolve2 } from "path";
+import { existsSync as existsSync5 } from "node:fs";
+import { isAbsolute, resolve as resolve2 } from "node:path";
 function splitToolArgs(cwd, toolArgs = [], { valueFlags = [] } = {}) {
   const takesValue = new Set(valueFlags);
   const options = [];
@@ -535,9 +543,9 @@ function splitToolArgs(cwd, toolArgs = [], { valueFlags = [] } = {}) {
 }
 
 // src/shared/resolve-bin.ts
-import { existsSync as existsSync6 } from "fs";
-import { createRequire } from "module";
-import { delimiter, dirname, join as join5 } from "path";
+import { existsSync as existsSync6 } from "node:fs";
+import { createRequire } from "node:module";
+import { delimiter, dirname, join as join5 } from "node:path";
 var require2 = createRequire(import.meta.url);
 function resolveBin(fromDir, name) {
   let dir = fromDir;
@@ -553,9 +561,9 @@ function binFromOwnInstall(packageName, binName) {
   try {
     const manifest = require2.resolve(`${packageName}/package.json`);
     const bin = require2(manifest).bin;
-    const relative7 = typeof bin === "string" ? bin : bin?.[binName];
-    if (!relative7) return void 0;
-    const executable = join5(dirname(manifest), relative7);
+    const relative8 = typeof bin === "string" ? bin : bin?.[binName];
+    if (!relative8) return void 0;
+    const executable = join5(dirname(manifest), relative8);
     return existsSync6(executable) ? executable : void 0;
   } catch {
     return void 0;
@@ -568,12 +576,12 @@ function binSearchPath(cwd) {
 }
 
 // src/roles/build/plan.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:fs";
+import { join as join10 } from "node:path";
 
 // src/core/config/existing-command.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync5 } from "node:fs";
+import { join as join6 } from "node:path";
 
 // src/shared/jsonc.ts
 import { parse, printParseErrorCode } from "jsonc-parser";
@@ -623,8 +631,8 @@ function existingCommand(cwd, target) {
 }
 
 // src/core/config/nx-target.ts
-import { existsSync as existsSync7 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join7 } from "node:path";
 function nxTargetMetadataOperations(options) {
   const { targets } = options;
   if (Object.keys(targets).length === 0) return [];
@@ -689,8 +697,8 @@ function keepsOtherCommands(script, sentinelCommand) {
 }
 
 // src/roles/format/read-adoption.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
+import { join as join8 } from "node:path";
 
 // src/roles/format/config-policy.ts
 var FORMAT_CONFIG_FILE = ".oxfmtrc.json";
@@ -901,8 +909,8 @@ function devTargetOperations(cwd, devScript) {
 }
 
 // src/roles/build/nest/adopt.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
+import { join as join9 } from "node:path";
 var NEST_CONFIG_FILE = "vite.config.mts";
 function asSource(value, depth) {
   const pad = "  ".repeat(depth);
@@ -1445,8 +1453,8 @@ var ViteDevAdapter = class extends ViteRoleAdapter {
 };
 
 // src/roles/build/declared-outputs.ts
-import { existsSync as existsSync11, rmSync, statSync, writeFileSync } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync11, rmSync, statSync, writeFileSync } from "node:fs";
+import { join as join11 } from "node:path";
 function declaredBuildTarget(cwd) {
   return readProjectPackageJson(cwd).nx?.targets?.[BUILD_SCRIPT_NAME];
 }
@@ -1492,7 +1500,7 @@ function outputsProblem(cwd, startedAt) {
 }
 
 // src/roles/build/prerequisite.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 var PREBUILD_SCRIPT_NAME = `pre${BUILD_SCRIPT_NAME}`;
 function insideBuildScript(env = process.env) {
   return env.npm_lifecycle_event === BUILD_SCRIPT_NAME;
@@ -1618,13 +1626,13 @@ function registerBuild() {
 }
 
 // src/roles/format/adapters/oxfmt/oxfmt.adapter.ts
-import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
-import { join as join16 } from "path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "node:fs";
+import { join as join16 } from "node:path";
 
 // src/core/config/has-source.ts
-import { readdirSync } from "fs";
-import { extname, join as join12, relative as relative2 } from "path";
+import { readdirSync } from "node:fs";
+import { extname, join as join12, relative as relative2 } from "node:path";
 var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -1742,8 +1750,8 @@ function writesWhenRewritten(name, command) {
 var CHECK_SCRIPT_NAMES = /* @__PURE__ */ new Set(["lint", "format", "check", "test", "typecheck", "verify"]);
 
 // src/roles/format/inherited-ignores.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "node:fs";
+import { join as join13 } from "node:path";
 var ROOT_IGNORE_FILE = ".prettierignore";
 function isPattern(line) {
   const trimmed = line.trim();
@@ -1808,13 +1816,13 @@ function needsSvelteCompiler(output) {
 }
 
 // src/roles/format/prettier-config.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
+import { join as join15 } from "node:path";
 
 // src/roles/format/resolve-oxfmt.ts
-import { readFileSync as readFileSync10 } from "fs";
-import { createRequire as createRequire2 } from "module";
-import { dirname as dirname2, join as join14 } from "path";
+import { readFileSync as readFileSync10 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname2, join as join14 } from "node:path";
 function resolveOxfmt(cwd) {
   return resolveBin(cwd, "oxfmt") ?? binFromOwnInstall("oxfmt", "oxfmt");
 }
@@ -2314,9 +2322,9 @@ function registerFormat() {
 }
 
 // src/roles/lint/adapters/oxlint/oxlint.adapter.ts
-import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync22, readFileSync as readFileSync20, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join26 } from "path";
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { existsSync as existsSync22, readFileSync as readFileSync20, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join26 } from "node:path";
 
 // src/core/config/deferred-rules.ts
 function deferredRuleNames(rules) {
@@ -2324,8 +2332,8 @@ function deferredRuleNames(rules) {
 }
 
 // src/core/fix-report.ts
-import { statSync as statSync2 } from "fs";
-import { join as join17 } from "path";
+import { statSync as statSync2 } from "node:fs";
+import { join as join17 } from "node:path";
 var CONFIG_REFUSED = /failed to parse .*config|invalid config file/i;
 function readFailure(output) {
   const lines = output.split("\n").map((line2) => line2.trim());
@@ -2360,8 +2368,12 @@ function changedSince(cwd, before, extensions) {
   return changed.sort();
 }
 var NAMED_IN_REPORT = 5;
+var NOT_INSTALLED_YET = /invalid config file[\s\S]*node_modules/i;
 function describeFixOutcome(outcome, toolLabel) {
   if (outcome.failure !== void 0) {
+    if (NOT_INSTALLED_YET.test(outcome.failure)) {
+      return `the ${toolLabel} preset is not installed in this module yet, which is expected: this command just added it and the install comes next. Nothing was fixed. Run \`pnpm install\`, then \`sentinel --run --${toolLabel} --fix\` to clear what a machine can clear.`;
+    }
     return `the ${toolLabel} autofix could not run, so nothing was fixed and this module has not been checked: ${outcome.failure}`;
   }
   if (outcome.changed.length === 0) return `the ${toolLabel} autofix changed nothing`;
@@ -2372,8 +2384,8 @@ function describeFixOutcome(outcome, toolLabel) {
 }
 
 // src/roles/lint/module-baseline.ts
-import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
+import { join as join18 } from "node:path";
 var LINT_BASELINE_FILE = ".oxlintrc.baseline.json";
 var LINT_MEASURE_FILE = ".oxlintrc.measure.json";
 var LINT_BASELINE_SPECIFIER = `./${LINT_BASELINE_FILE}`;
@@ -4247,8 +4259,8 @@ function downgradedRulesFor(preset) {
 }
 
 // src/roles/lint/extra-layers.ts
-import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
-import { isAbsolute as isAbsolute2, join as join19, resolve as resolve3 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync14 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join19, resolve as resolve3 } from "node:path";
 function ruleCount(cwd, specifier) {
   const path = isAbsolute2(specifier) ? specifier : resolve3(cwd, specifier);
   if (!existsSync16(path)) return void 0;
@@ -4333,8 +4345,8 @@ function errorCountsByConfigRule(stdout) {
 }
 
 // src/core/config/read-adoption.ts
-import { existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync16 } from "node:fs";
+import { join as join21 } from "node:path";
 
 // src/core/config/owned-keys.ts
 function presetOwnedKeys(config, permitted, presetSets) {
@@ -4349,8 +4361,8 @@ function localOnlyKeys(config, permitted, presetSets) {
 }
 
 // src/core/config/resolve-config-target.ts
-import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync15 } from "node:fs";
+import { join as join20 } from "node:path";
 function readExtends(absolutePath) {
   let parsed;
   try {
@@ -4441,10 +4453,10 @@ function readLintAdoption(cwd) {
 }
 
 // src/roles/lint/resolve-oxlint.ts
-import { existsSync as existsSync19 } from "fs";
-import { createRequire as createRequire3 } from "module";
-import { delimiter as delimiter2, dirname as dirname3, join as join22 } from "path";
-import { fileURLToPath } from "url";
+import { existsSync as existsSync19 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { delimiter as delimiter2, dirname as dirname3, join as join22 } from "node:path";
+import { fileURLToPath } from "node:url";
 var PACKAGE_OF = {
   oxlint: "oxlint",
   tsgolint: "oxlint-tsgolint"
@@ -4486,12 +4498,12 @@ function oxlintSearchPath(cwd) {
 }
 
 // src/roles/lint/adapters/oxlint/plan.ts
-import { existsSync as existsSync21, readFileSync as readFileSync19 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync19 } from "node:fs";
+import { join as join25 } from "node:path";
 
 // src/roles/lint/eslint-ignores.ts
-import { existsSync as existsSync20, readFileSync as readFileSync17 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync17 } from "node:fs";
+import { join as join23 } from "node:path";
 import { parseSync as parseSync2 } from "oxc-parser";
 
 // src/shared/ast.ts
@@ -4615,8 +4627,8 @@ function lintPresetFor(preset) {
 }
 
 // src/roles/lint/rename-suppressions.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync18, statSync as statSync3 } from "fs";
-import { join as join24, relative as relative3 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync18, statSync as statSync3 } from "node:fs";
+import { join as join24, relative as relative3 } from "node:path";
 var SOURCE_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -5393,7 +5405,10 @@ function registerLint() {
 }
 
 // src/roles/test/adapters/vitest/vitest.adapter.ts
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync30 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { isAbsolute as isAbsolute3, join as join38, resolve as resolve6 } from "node:path";
 
 // src/roles/test/presets/toolchain.json
 var toolchain_default2 = {
@@ -5470,17 +5485,18 @@ function testTarget(options) {
 }
 
 // src/roles/test/jest-migration.ts
-import { existsSync as existsSync28, readFileSync as readFileSync28 } from "fs";
-import { join as join35 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync28, readdirSync as readdirSync8 } from "node:fs";
+import { createRequire as createRequire6 } from "node:module";
+import { dirname as dirname8, join as join36, relative as relative7 } from "node:path";
 
 // src/roles/test/codemod/migrate-module.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync25, statSync as statSync6 } from "fs";
-import { join as join31 } from "path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync25, statSync as statSync6 } from "node:fs";
+import { join as join31 } from "node:path";
 import { parseSync as parseSync8 } from "oxc-parser";
 
 // src/roles/test/read-adoption.ts
-import { existsSync as existsSync23, readFileSync as readFileSync21, readdirSync as readdirSync3 } from "fs";
-import { join as join27, relative as relative4 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync21, readdirSync as readdirSync3 } from "node:fs";
+import { join as join27, relative as relative4 } from "node:path";
 var JEST_CONFIG_FILES = [
   "jest.config.ts",
   "jest.config.js",
@@ -5600,6 +5616,17 @@ function readTestAdoption(cwd) {
   };
 }
 
+// src/roles/test/support-file-name.ts
+var JEST_PREFIX = "jest.";
+var VITEST_PREFIX = "vitest.";
+function vitestSupportName(relative8) {
+  const cut = relative8.lastIndexOf("/");
+  const directory = cut === -1 ? "" : relative8.slice(0, cut + 1);
+  const base = relative8.slice(cut + 1);
+  if (!base.startsWith(JEST_PREFIX)) return relative8;
+  return `${directory}${VITEST_PREFIX}${base.slice(JEST_PREFIX.length)}`;
+}
+
 // src/roles/test/codemod/migrate-file.ts
 import { parseSync as parseSync7 } from "oxc-parser";
 
@@ -5715,7 +5742,7 @@ function rewriteAssertionReturnValue(source, program) {
     for (const reading of readings) {
       const from = reading.start;
       let to = reading.end;
-      while (to < source.length && /[\s;]/.test(source[to])) to += 1;
+      while (to < source.length && /[ \t;]/.test(source[to])) to += 1;
       let head = from;
       while (head > 0 && /[ \t]/.test(source[head - 1])) head -= 1;
       if (head > 0 && source[head - 1] === "\n") head -= 1;
@@ -6450,9 +6477,9 @@ ${source}`;
 }
 
 // src/roles/test/codemod/named-rules.ts
-import { existsSync as existsSync24, readFileSync as readFileSync22 } from "fs";
-import { createRequire as createRequire4 } from "module";
-import { dirname as dirname4, join as join28 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync22 } from "node:fs";
+import { createRequire as createRequire4 } from "node:module";
+import { dirname as dirname4, join as join28 } from "node:path";
 function isCommonJsPackage(fromFile, specifier) {
   if (specifier.startsWith(".") || specifier.startsWith("/")) return false;
   let resolved;
@@ -6581,12 +6608,47 @@ function applyNamedRules(source, program, fileName = "") {
   const applied = /* @__PURE__ */ new Set();
   const asyncify = /* @__PURE__ */ new Set();
   const mocked = mockedSpecifiers(program);
-  const wholeStatement = /* @__PURE__ */ new Set();
+  const wholeStatement = /* @__PURE__ */ new Map();
   walk(program, (node) => {
     if (node.type !== "ExpressionStatement") return;
     const expression = node.expression;
-    if (expression !== void 0) wholeStatement.add(expression);
+    if (expression !== void 0) wholeStatement.set(expression, node);
+  });
+  const standsAlone = /* @__PURE__ */ new Set();
+  const alone = (node) => {
+    if (node !== void 0) standsAlone.add(node);
+  };
+  walk(program, (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        return alone(node.init);
+      case "AssignmentExpression":
+        return alone(node.right);
+      case "ReturnStatement":
+      case "ExportDefaultDeclaration":
+        return alone(node.argument ?? node.declaration);
+      case "ArrowFunctionExpression":
+        return node.expression === true ? alone(node.body) : void 0;
+      case "ConditionalExpression":
+        alone(node.consequent);
+        return alone(node.alternate);
+      case "ArrayExpression":
+        return (node.elements ?? []).forEach((e) => alone(e ?? void 0));
+      case "Property":
+      case "ObjectProperty":
+        return node.shorthand === true ? void 0 : alone(node.value);
+      case "CallExpression":
+      case "NewExpression":
+        return (node.arguments ?? []).forEach((a) => alone(a));
+      default:
+        return;
+    }
   });
+  const placed = (node, expression, trailing = "") => {
+    if (trailing !== "") return `(${expression})${trailing}`;
+    if (wholeStatement.has(node)) return expression;
+    return standsAlone.has(node) ? expression : `(${expression})`;
+  };
   const handedToTheRunnerAsAModule = /* @__PURE__ */ new Set();
   walk(program, (node) => {
     const returned = mockFactoryReturn(node);
@@ -6616,7 +6678,7 @@ function applyNamedRules(source, program, fileName = "") {
         edits.push({
           start: node.start,
           end: node.end,
-          text: `(await import(${argumentText(source, node)}))`
+          text: placed(node, `await import(${argumentText(source, node)})`)
         });
         applied.add("jest.requireMock");
         if (enclosing !== void 0 && enclosing.async !== true) asyncify.add(enclosing);
@@ -6628,7 +6690,7 @@ function applyNamedRules(source, program, fileName = "") {
       edits.push({
         start: node.start,
         end: node.end,
-        text: `(await vi.${asyncReplacement}(${argumentText(source, node)}))`
+        text: placed(node, `await vi.${asyncReplacement}(${argumentText(source, node)})`)
       });
       applied.add(`jest.${member}`);
       if (enclosing !== void 0 && enclosing.async !== true) asyncify.add(enclosing);
@@ -6641,7 +6703,7 @@ function applyNamedRules(source, program, fileName = "") {
       edits.push({
         start: node.start,
         end: node.end,
-        text: wholeStatement.has(node) ? `await import(${argumentText(source, node)});` : `(await import(${argumentText(source, node)}))${interop}`
+        text: placed(node, `await import(${argumentText(source, node)})`, interop)
       });
       applied.add("require");
       if (enclosing !== void 0 && enclosing.async !== true) asyncify.add(enclosing);
@@ -6932,6 +6994,78 @@ function rewriteMockFactoryDefault(source, program, defaultImported) {
   };
 }
 
+// src/roles/test/codemod/mock-promise-resolve.ts
+var MOCK_FACTORY = /* @__PURE__ */ new Set(["fn", "spyOn"]);
+function isMockFactory(source, node) {
+  if (node.type !== "CallExpression") return false;
+  const callee = node.callee;
+  if (callee?.type !== "MemberExpression") return false;
+  const object = callee.object;
+  const property = callee.property;
+  if (object?.type !== "Identifier" || property?.type !== "Identifier") return false;
+  const runner = source.slice(object.start, object.end);
+  const method = source.slice(property.start, property.end);
+  return (runner === "jest" || runner === "vi") && MOCK_FACTORY.has(method);
+}
+function resolvedValue(source, executor) {
+  if (executor.type !== "ArrowFunctionExpression" && executor.type !== "FunctionExpression") {
+    return void 0;
+  }
+  const params = executor.params;
+  if (params?.length !== 1) return void 0;
+  const parameter = params[0];
+  if (parameter.type !== "Identifier") return void 0;
+  const resolveName = source.slice(parameter.start, parameter.end);
+  const body = executor.body;
+  if (body === void 0) return void 0;
+  let call;
+  if (body.type === "BlockStatement") {
+    const statements = body.body;
+    if (statements?.length !== 1) return void 0;
+    const only = statements[0];
+    if (only.type !== "ExpressionStatement") return void 0;
+    call = only.expression;
+  } else {
+    call = body;
+  }
+  if (call?.type !== "CallExpression") return void 0;
+  const callee = call.callee;
+  if (callee?.type !== "Identifier") return void 0;
+  if (source.slice(callee.start, callee.end) !== resolveName) return void 0;
+  const args = call.arguments;
+  if (args?.length !== 1) return void 0;
+  return args[0];
+}
+function rewriteMockPromiseResolve(source, program) {
+  const edits = [];
+  walk(program, (node) => {
+    if (!isMockFactory(source, node)) return;
+    for (const argument of node.arguments ?? []) {
+      walk(argument, (inner) => {
+        if (inner.type !== "NewExpression") return;
+        const callee = inner.callee;
+        if (callee?.type !== "Identifier") return;
+        if (source.slice(callee.start, callee.end) !== "Promise") return;
+        if ((inner.typeArguments ?? inner.typeParameters) !== void 0) return;
+        const executors = inner.arguments ?? [];
+        if (executors.length !== 1) return;
+        const value = resolvedValue(source, executors[0]);
+        if (value === void 0) return;
+        edits.push({
+          start: inner.start,
+          end: inner.end,
+          text: `Promise.resolve(${source.slice(value.start, value.end)})`
+        });
+      });
+    }
+  });
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = `${result.slice(0, edit.start)}${edit.text}${result.slice(edit.end)}`;
+  }
+  return { source: result, rewritten: edits.length };
+}
+
 // src/roles/test/codemod/propagate-await.ts
 import { parseSync as parseSync5 } from "oxc-parser";
 var FUNCTIONS3 = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"]);
@@ -7059,9 +7193,9 @@ function propagateAwait(fileName, source, original, elsewhere = /* @__PURE__ */
 }
 
 // src/roles/test/codemod/reexport-barrel-mock.ts
-import { readFileSync as readFileSync23, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
-import { createRequire as createRequire5 } from "module";
-import { dirname as dirname5, join as join29 } from "path";
+import { readFileSync as readFileSync23, readdirSync as readdirSync4, statSync as statSync4 } from "node:fs";
+import { createRequire as createRequire5 } from "node:module";
+import { dirname as dirname5, join as join29 } from "node:path";
 var MEMBER_TYPES13 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 var PACKAGE_SUBPATH = /^(@[^/]+\/[^/]+|[^@.][^/]*)\/(.+)$/;
 var PURE_REEXPORT = /^module\.exports\s*=\s*require\(\s*(['"])([^'"]+)\1\s*\)\s*;?$/;
@@ -7160,12 +7294,9 @@ ${text}` });
 // src/roles/test/codemod/repoint-msw.ts
 import { parseSync as parseSync6 } from "oxc-parser";
 var SENTINEL_MSW_SERVER = "@hublo/sentinel/test/msw";
-var MSW_SERVER_MODULE = /(^|\/)msw\/server$/;
+var SENTINEL_MSW_API = "@hublo/sentinel/test/tools/msw";
 var MSW_PACKAGE = /^msw$/;
-function importsMswPackage(declaration) {
-  const source = declaration.source?.value;
-  return source !== void 0 && MSW_PACKAGE.test(source);
-}
+var MSW_SERVER_MODULE = /(^|\/)msw\/server$/;
 function importsServer(declaration) {
   return (declaration.specifiers ?? []).some((specifier) => {
     const imported = specifier.imported;
@@ -7181,21 +7312,28 @@ function repointMswServer(fileName, source) {
     if (node.type !== "ImportDeclaration") return;
     const specifier = node.source;
     if (specifier?.value === void 0) return;
-    const isServerModule = MSW_SERVER_MODULE.test(specifier.value) && importsServer(node);
-    if (!isServerModule && !importsMswPackage(node)) return;
-    edits.push({ start: specifier.start, end: specifier.end });
+    const isServer = MSW_SERVER_MODULE.test(specifier.value) && importsServer(node);
+    const isPackage2 = MSW_PACKAGE.test(specifier.value);
+    if (!isServer && !isPackage2) return;
+    edits.push({
+      start: specifier.start,
+      end: specifier.end,
+      to: isServer ? SENTINEL_MSW_SERVER : SENTINEL_MSW_API
+    });
   });
   if (edits.length === 0) return { source, repointed: false };
   let rewritten = source;
   for (const edit of edits.sort((left, right) => right.start - left.start)) {
     const quote = source[edit.start] === '"' ? '"' : "'";
-    rewritten = rewritten.slice(0, edit.start) + `${quote}${SENTINEL_MSW_SERVER}${quote}` + rewritten.slice(edit.end);
+    rewritten = rewritten.slice(0, edit.start) + `${quote}${edit.to}${quote}` + rewritten.slice(edit.end);
   }
   return { source: rewritten, repointed: true };
 }
 
 // src/roles/test/codemod/spy-instance-type.ts
 var SPY_TYPES = /* @__PURE__ */ new Set(["SpyInstance"]);
+var QUALIFIED_ONLY = /* @__PURE__ */ new Set(["Mock"]);
+var VITEST_NAME = { SpyInstance: "MockInstance", Mock: "Mock" };
 function typeNameOf(source, node) {
   const name = node.typeName;
   if (name === void 0) return void 0;
@@ -7207,17 +7345,20 @@ function rewriteSpyInstanceType(source, program) {
     if (node.type !== "TSTypeReference") return;
     const written = typeNameOf(source, node);
     if (written === void 0) return;
-    const bare = written.startsWith("jest.") ? written.slice("jest.".length) : written;
-    if (!SPY_TYPES.has(bare)) return;
+    const qualified = written.startsWith("jest.");
+    const bare = qualified ? written.slice("jest.".length) : written;
+    if (!SPY_TYPES.has(bare) && !(qualified && QUALIFIED_ONLY.has(bare))) return;
     const args = (node.typeArguments ?? node.typeParameters)?.params;
     if (args === void 0 || args.length === 0) return;
     const text = (argument) => source.slice(argument.start, argument.end);
     const returns = text(args[0]);
-    const parameters = args.length > 1 ? `...args: ${text(args[1])}` : "...args: any[]";
+    const parameters = args.length > 1 ? `...args: ${text(args[1])}` : "...args: never[]";
+    const target = VITEST_NAME[bare];
     edits.push({
       start: node.start,
       end: node.end,
-      text: `MockInstance<(${parameters}) => ${returns}>`
+      text: `${target}<(${parameters}) => ${returns}>`,
+      imports: target
     });
   });
   let result = source;
@@ -7227,7 +7368,8 @@ function rewriteSpyInstanceType(source, program) {
   return {
     source: result,
     rewritten: edits.length,
-    typeImports: edits.length > 0 ? ["MockInstance"] : []
+    // Only the names actually written, so a file does not import a type it never uses.
+    typeImports: [...new Set(edits.map((edit) => edit.imports))]
   };
 }
 
@@ -7315,7 +7457,10 @@ function migrateTestFile(fileName, source, defaultImported = /* @__PURE__ */ new
   const afterEmpty = parse2(fileName, emptyImplementations.source);
   if (afterEmpty === void 0) return unparsable("empty mock implementation");
   const hooks = rewriteHookReturnValue(emptyImplementations.source, afterEmpty);
-  const awaited = propagateAwait(fileName, hooks.source, original, asyncHelpers);
+  const afterHooks = parse2(fileName, hooks.source);
+  if (afterHooks === void 0) return unparsable("hook return value");
+  const promises = rewriteMockPromiseResolve(hooks.source, afterHooks);
+  const awaited = propagateAwait(fileName, promises.source, original, asyncHelpers);
   const program = parse2(fileName, awaited.source);
   if (program === void 0) return unparsable("hook body");
   const hoist = hoistCapturedBindings(
@@ -7366,8 +7511,8 @@ function migrateTestFile(fileName, source, defaultImported = /* @__PURE__ */ new
 }
 
 // src/roles/test/codemod/test-support-files.ts
-import { existsSync as existsSync25, readFileSync as readFileSync24, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
-import { dirname as dirname6, join as join30, relative as relative5, resolve as resolve4 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync24, readdirSync as readdirSync5, statSync as statSync5 } from "node:fs";
+import { dirname as dirname6, join as join30, relative as relative5, resolve as resolve4 } from "node:path";
 var SKIPPED = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", ".git", ".vite"]);
 var TEST_FILE2 = /\.(spec|test)\.[cm]?[jt]sx?$/;
 var SOURCE_FILE = /\.[cm]?[jt]sx?$/;
@@ -7524,14 +7669,16 @@ function migrateModuleTests(cwd, setupFiles = []) {
   let hoisted = 0;
   const defaultImported = defaultImportedSpecifiers(cwd);
   const asyncHelpers = /* @__PURE__ */ new Set();
-  for (const relative7 of listTestSupportFiles(cwd, setupFiles)) {
-    const source = read2(join31(cwd, relative7));
+  for (const relative8 of listTestSupportFiles(cwd, setupFiles)) {
+    const source = read2(join31(cwd, relative8));
     if (source === void 0) {
-      blockers.push({ file: relative7, reason: "this file could not be read" });
+      blockers.push({ file: relative8, reason: "this file could not be read" });
       continue;
     }
-    const migrated = migrateTestFile(join31(cwd, relative7), source, defaultImported);
-    if (!migrated.changed) continue;
+    const migrated = migrateTestFile(join31(cwd, relative8), source, defaultImported);
+    const renamedTo = vitestSupportName(relative8);
+    if (!migrated.changed && renamedTo === relative8) continue;
+    if (renamedTo !== relative8) operations.push({ kind: "delete", path: relative8 });
     const before = parse3(source);
     const after = parse3(migrated.source);
     if (before !== void 0 && after !== void 0) {
@@ -7542,41 +7689,44 @@ function migrateModuleTests(cwd, setupFiles = []) {
     }
     files++;
     renamed += migrated.renamed;
-    operations.push({ kind: "write", path: relative7, contents: migrated.source });
+    operations.push({ kind: "write", path: renamedTo, contents: migrated.source });
   }
-  for (const relative7 of listTestFiles(cwd)) {
-    const source = read2(join31(cwd, relative7));
+  for (const relative8 of listTestFiles(cwd)) {
+    const source = read2(join31(cwd, relative8));
     if (source === void 0) {
-      blockers.push({ file: relative7, reason: "this file could not be read" });
+      blockers.push({ file: relative8, reason: "this file could not be read" });
       continue;
     }
-    const migrated = migrateTestFile(join31(cwd, relative7), source, defaultImported, asyncHelpers);
+    const migrated = migrateTestFile(join31(cwd, relative8), source, defaultImported, asyncHelpers);
     for (const member of migrated.unhandled) {
       blockers.push({
-        file: `${relative7}:${member.line}`,
+        file: `${relative8}:${member.line}`,
         reason: member.rule === void 0 ? `${member.member} has no rule, and guessing one is how a suite goes green for the wrong reason` : `${member.member} needs ${member.rule}`
       });
     }
     for (const refusal of migrated.refusals) {
-      blockers.push({ file: relative7, reason: refusal.reason });
+      blockers.push({ file: relative8, reason: refusal.reason });
     }
     if (!migrated.changed) continue;
     files++;
     renamed += migrated.renamed;
     if (migrated.hoisted.length > 0) hoisted++;
-    operations.push({ kind: "write", path: relative7, contents: migrated.source });
+    operations.push({ kind: "write", path: relative8, contents: migrated.source });
   }
   return blockers.length > 0 ? { operations: [], files, renamed, hoisted, blockers } : { operations, files, renamed, hoisted, blockers: [] };
 }
 
 // src/roles/test/nest/generate-config.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync26, statSync as statSync7 } from "fs";
-import { join as join32, relative as relative6 } from "path";
+import { existsSync as existsSync26, readdirSync as readdirSync7, readFileSync as readFileSync26, statSync as statSync7 } from "node:fs";
+import { join as join32, relative as relative6 } from "node:path";
 var NEST_TEST_PRESET_SPECIFIER = "@hublo/sentinel/test/nest";
-var SENTINEL_TEST_SETUP = "@hublo/sentinel/test/setup/nest";
+var REACT_TEST_PRESET_SPECIFIER = "@hublo/sentinel/test/react";
+function flavourOf(reading) {
+  return reading.testEnvironment === "jsdom" ? "react" : "nest";
+}
+var SENTINEL_TEST_SETUP = "@hublo/sentinel/test/setup/jest-parity";
 var SENTINEL_MSW_SETUP = "@hublo/sentinel/test/setup/msw-lifecycle";
 var SENTINEL_WORKSPACE_SETUP = "@hublo/sentinel/test/setup/workspace";
-var NEST_TEST_CONFIG_FILE = "vitest.config.mts";
 function hopsToRoot(cwd, workspaceRoot) {
   const up = relative6(cwd, workspaceRoot).replaceAll("\\", "/");
   return up === "" ? "." : up;
@@ -7643,14 +7793,29 @@ function readModuleTraits(cwd) {
   return traits;
 }
 var withoutRootDir = (value) => value.replaceAll("<rootDir>/", "./").replaceAll("<rootDir>", ".");
-function setupBlock(reading, msw) {
+function ownsMswLifecycle(cwd, reading) {
+  const declared = [...reading.setupFiles ?? [], ...reading.setupFilesAfterEnv ?? []].filter(
+    (file) => !file.endsWith("jest.setup.after.env.js")
+  );
+  for (const raw of declared) {
+    const file = join32(cwd, raw.replaceAll("<rootDir>/", "").replaceAll("<rootDir>", "."));
+    if (!existsSync26(file)) continue;
+    try {
+      if (/\.listen\s*\(/.test(readFileSync26(file, "utf8"))) return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+function setupBlock(cwd, reading, msw) {
   const declared = [...reading.setupFiles ?? [], ...reading.setupFilesAfterEnv ?? []];
   const namedTheRootSetup = declared.some((file) => file.endsWith("jest.setup.after.env.js"));
-  const own = declared.filter((file) => !file.endsWith("jest.setup.after.env.js")).map((file) => `'${withoutRootDir(file)}'`);
+  const own = declared.filter((file) => !file.endsWith("jest.setup.after.env.js")).map((file) => `'${vitestSupportName(withoutRootDir(file))}'`);
   const sentinel = [
     `'${SENTINEL_TEST_SETUP}'`,
     ...namedTheRootSetup ? [`'${SENTINEL_WORKSPACE_SETUP}'`] : [],
-    ...msw ? [`'${SENTINEL_MSW_SETUP}'`] : []
+    ...msw && namedTheRootSetup && !ownsMswLifecycle(cwd, reading) ? [`'${SENTINEL_MSW_SETUP}'`] : []
   ];
   return `        setupFiles: [${[...sentinel, ...own].join(", ")}],`;
 }
@@ -7677,7 +7842,7 @@ function timeoutBlock(reading) {
 }
 function globalSetupBlock(reading) {
   if (reading.globalSetup === void 0) return "";
-  const files = reading.globalSetup.map((file) => `'${withoutRootDir(file)}'`).join(", ");
+  const files = reading.globalSetup.map((file) => `'${vitestSupportName(withoutRootDir(file))}'`).join(", ");
   return `        globalSetup: [${files}],`;
 }
 function includeBlock(reading) {
@@ -7697,7 +7862,8 @@ function aliasBlock(reading) {
   if (reading.aliases === void 0 || reading.aliases.length === 0) return "";
   const entries = reading.aliases.map((alias) => {
     const pattern = alias.find.replaceAll(String.raw`\\`, "\\").replaceAll("/", String.raw`\/`);
-    const target = isPackage(alias.replacement) ? `'${alias.replacement}'` : `path.resolve(import.meta.dirname, '${withoutRootDir(alias.replacement)}')`;
+    const deadToken = /<rootdir>/i.test(alias.replacement) && !alias.replacement.includes("<rootDir>");
+    const target = isPackage(alias.replacement) ? `'${alias.replacement}'` : deadToken ? `'${alias.replacement}'` : `path.resolve(import.meta.dirname, '${withoutRootDir(alias.replacement)}')`;
     return `          { find: /${pattern}/, replacement: ${target} },`;
   });
   return ["      resolve: {", "        alias: [", ...entries, "        ],", "      },"].join("\n");
@@ -7712,7 +7878,7 @@ function generateNestTestConfig(cwd, reading, target = "test") {
   const up = hopsToRoot(cwd, workspaceRoot);
   const test = [
     environmentBlock(reading),
-    setupBlock(reading, traits.msw),
+    setupBlock(cwd, reading, traits.msw),
     envBlock(reading),
     timeoutBlock(reading),
     concurrencyBlock(cwd, reading, target),
@@ -7727,7 +7893,7 @@ function generateNestTestConfig(cwd, reading, target = "test") {
     `import path from 'node:path'`,
     "",
     ...needsDefaults ? [`import { configDefaults } from 'vitest/config'`, ""] : [],
-    `import { defineConfig, nestTestConfig } from '${NEST_TEST_PRESET_SPECIFIER}'`
+    flavourOf(reading) === "react" ? `import { defineConfig, reactTestConfig } from '${REACT_TEST_PRESET_SPECIFIER}'` : `import { defineConfig, nestTestConfig } from '${NEST_TEST_PRESET_SPECIFIER}'`
   ].join("\n");
   const overrides = [aliasBlock(reading), "      test: {", ...test, "      },"].filter(
     (line) => line !== ""
@@ -7738,7 +7904,7 @@ function generateNestTestConfig(cwd, reading, target = "test") {
     source: `${imports}
 
 export default defineConfig(
-  nestTestConfig({
+  ${flavourOf(reading) === "react" ? "reactTestConfig" : "nestTestConfig"}({
     root: import.meta.dirname,
     workspaceRoot: path.resolve(import.meta.dirname, '${up}'),${decoratorLine}
     overrides: {
@@ -7751,8 +7917,8 @@ ${overrides.join("\n")}
 }
 
 // src/roles/test/nest/read-jest-config.ts
-import { existsSync as existsSync26, readFileSync as readFileSync27 } from "fs";
-import { join as join33 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync27 } from "node:fs";
+import { join as join33 } from "node:path";
 var CARRIED = [
   "testEnvironment",
   "coverageDirectory",
@@ -7942,7 +8108,7 @@ function extendedConfig(source, cwd) {
       (name) => name.replace(/^\.\//, "")
     );
     const file = candidates.find(
-      (name) => /^jest[\w.-]*\.(ts|js)$/.test(name) && existsSync26(join33(cwd, name))
+      (name) => /^jest[\w.-]*\.(ts|js)$/.test(name) && existsSync27(join33(cwd, name))
     );
     if (file === void 0) continue;
     if (!new RegExp(String.raw`\{\s*\.\.\.${binding}\b`).test(source)) continue;
@@ -7969,8 +8135,8 @@ function sideEffects(source, extended) {
   return found;
 }
 function readJestConfig(cwd, named) {
-  const file = named ?? JEST_CONFIG_FILES.find((name) => existsSync26(join33(cwd, name)));
-  if (file === void 0 || !existsSync26(join33(cwd, file))) return void 0;
+  const file = named ?? JEST_CONFIG_FILES.find((name) => existsSync27(join33(cwd, name)));
+  if (file === void 0 || !existsSync27(join33(cwd, file))) return void 0;
   let source;
   try {
     source = readFileSync27(join33(cwd, file), "utf8");
@@ -8054,8 +8220,8 @@ function readJestConfig(cwd, named) {
 }
 
 // src/roles/test/nest/run-modes.ts
-import { existsSync as existsSync27 } from "fs";
-import { basename as basename2, join as join34 } from "path";
+import { existsSync as existsSync28 } from "node:fs";
+import { basename as basename2, join as join34 } from "node:path";
 var JEST_EXECUTOR = "@nx/jest:jest";
 var PRIMARY_CONFIG_FILE = "vitest.config.mts";
 var PRIMARY_TARGET = "test";
@@ -8076,7 +8242,7 @@ function runModes(cwd, fallback) {
     const jestConfig = entry.options?.jestConfig;
     if (jestConfig === void 0) continue;
     const name = configName(jestConfig);
-    if (!existsSync27(join34(cwd, name))) continue;
+    if (!existsSync28(join34(cwd, name))) continue;
     declared.push({
       target,
       jestConfig: name,
@@ -8100,12 +8266,59 @@ function runModes(cwd, fallback) {
   );
 }
 
+// src/roles/test/written-file-formatter.ts
+import { existsSync as existsSync29 } from "node:fs";
+import { dirname as dirname7, join as join35 } from "node:path";
+var PRETTIER_CONFIGS = [
+  ".prettierrc",
+  ".prettierrc.json",
+  ".prettierrc.json5",
+  ".prettierrc.yaml",
+  ".prettierrc.yml",
+  ".prettierrc.js",
+  ".prettierrc.cjs",
+  ".prettierrc.mjs",
+  ".prettierrc.toml",
+  "prettier.config.js",
+  "prettier.config.cjs",
+  "prettier.config.mjs"
+];
+function prettierConfigFrom(cwd) {
+  let dir = cwd;
+  for (; ; ) {
+    for (const name of PRETTIER_CONFIGS) {
+      if (existsSync29(join35(dir, name))) return join35(dir, name);
+    }
+    const parent = dirname7(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function writtenFileFormatter(cwd) {
+  if (readFormatAdoption(cwd).configFile !== null) {
+    const oxfmt = resolveOxfmt(cwd);
+    if (oxfmt !== void 0) {
+      return { bin: oxfmt, args: ["--write"], origin: "this module's own oxfmt config" };
+    }
+  }
+  const config = prettierConfigFrom(cwd);
+  const prettier = resolveBin(cwd, "prettier");
+  if (config !== void 0 && prettier !== void 0) {
+    return {
+      bin: prettier,
+      args: ["--write", "--log-level", "warn"],
+      origin: `the workspace's Prettier`
+    };
+  }
+  return void 0;
+}
+
 // src/roles/test/jest-migration.ts
 var SPEC_TSCONFIG = "tsconfig.spec.json";
 var VITEST_GLOBAL_TYPES = "vitest/globals";
 function specTypesOperation(cwd) {
-  const path = join35(cwd, SPEC_TSCONFIG);
-  if (!existsSync28(path)) return void 0;
+  const path = join36(cwd, SPEC_TSCONFIG);
+  if (!existsSync30(path)) return void 0;
   let config;
   try {
     config = parseJsonc(
@@ -8127,6 +8340,70 @@ function specTypesOperation(cwd) {
     }
   };
 }
+function shippedTypesPath(cwd, declaration) {
+  try {
+    const manifest = createRequire6(join36(cwd, "noop.cjs")).resolve("@hublo/sentinel/package.json");
+    const file = join36(dirname8(manifest), declaration);
+    if (existsSync30(file)) {
+      const path = relative7(cwd, file);
+      return path.startsWith(".") ? path : `./${path}`;
+    }
+  } catch {
+  }
+  return `./node_modules/@hublo/sentinel/${declaration}`;
+}
+function tsconfigFileListOperations(cwd) {
+  const operations = [];
+  let names;
+  try {
+    names = readdirSync8(cwd).filter((name) => TSCONFIG_FILE.test(name));
+  } catch {
+    return operations;
+  }
+  for (const name of names) {
+    let config;
+    try {
+      config = parseJsonc(
+        readFileSync28(join36(cwd, name), "utf8"),
+        name
+      );
+    } catch {
+      continue;
+    }
+    const include = Array.isArray(config?.include) ? rewriteFileList(config.include) : void 0;
+    const exclude = Array.isArray(config?.exclude) ? rewriteFileList(config.exclude) : void 0;
+    const files = Array.isArray(config?.files) ? rewriteFileList(config.files) : void 0;
+    const withTypes = name === SPEC_TSCONFIG ? withShippedTypes(cwd, files ?? config?.files) : void 0;
+    if (include === void 0 && exclude === void 0 && files === void 0 && withTypes === void 0)
+      continue;
+    operations.push({
+      kind: "merge-json",
+      path: name,
+      value: {
+        ...include === void 0 ? {} : { include },
+        ...exclude === void 0 ? {} : { exclude },
+        ...withTypes === void 0 ? files === void 0 ? {} : { files } : { files: withTypes }
+      }
+    });
+  }
+  return operations;
+}
+function rewriteFileList(entries) {
+  const rewritten = entries.filter((entry) => typeof entry !== "string" || !JEST_CONFIG_ENTRY.test(entry)).map((entry) => typeof entry === "string" ? vitestSupportName(entry) : entry);
+  const unchanged = rewritten.length === entries.length && rewritten.every((entry, index) => entry === entries[index]);
+  return unchanged ? void 0 : rewritten;
+}
+function withShippedTypes(cwd, files) {
+  const entries = Array.isArray(files) ? files : [];
+  const missing = SHIPPED_TYPES.filter(
+    (declaration) => !entries.some((entry) => entry.endsWith(declaration))
+  );
+  if (missing.length === 0) return void 0;
+  return [...entries, ...missing.map((declaration) => shippedTypesPath(cwd, declaration))];
+}
+var SHIPPED_TYPES = ["types/mock-extended.d.ts", "types/jest-global.d.ts"];
+var JEST_CONFIG_ENTRY = /(^|\/)jest\.[\w.-]*config\.[cm]?[jt]s$/;
+var TSCONFIG_FILE = /^tsconfig[\w.-]*\.json$/;
 function siblingScriptRewrites(cwd) {
   const rewrites = {};
   for (const [name, command] of Object.entries(moduleScripts(cwd))) {
@@ -8173,8 +8450,9 @@ function planJestMigration(context, adoption) {
       `${migration.blockers.length} thing(s) in this module's test files need a human before it can move. Nothing was written, because a config without its files is a suite calling jest.* under Vitest.${listed}`
     );
   }
-  const targets = projectTargets(context.cwd) ?? {};
-  const existingFor = (name) => targets[name];
+  const fromProject = projectTargets(context.cwd) ?? {};
+  const fromManifest = manifestTargets(context.cwd);
+  const existingFor = (name) => fromProject[name] ?? fromManifest[name];
   const siblings = siblingScriptRewrites(context.cwd);
   const specTypes = specTypesOperation(context.cwd);
   const scripts = Object.fromEntries(
@@ -8191,6 +8469,7 @@ function planJestMigration(context, adoption) {
     })),
     ...migration.operations,
     ...specTypes === void 0 ? [] : [specTypes],
+    ...tsconfigFileListOperations(context.cwd),
     manifestOperation(context.cwd, { ...scripts, ...siblings }),
     ...prepared.flatMap(
       ({ mode }) => nxTargetOperations({
@@ -8208,18 +8487,26 @@ function planJestMigration(context, adoption) {
       (name) => ({ kind: "delete", path: name })
     )
   ];
+  const escaping = (prepared[0]?.reading.aliases ?? []).map((alias) => alias.replacement).filter((replacement) => replacement.includes(".."));
   const notes = [
     `${migration.files} test file(s) migrated from jest to Vitest, ${migration.renamed} site(s) rewritten${migration.hoisted > 0 ? `, ${migration.hoisted} of them moving a mock factory's captures into vi.hoisted` : ""}.`,
-    `${NEST_TEST_CONFIG_FILE} written from what ${adoption.jestConfigs.join(", ")} declared, and that config deleted. Every specifier in the new one is a package name: nothing in it reaches outside this module.`
+    `${prepared.map(({ mode }) => mode.vitestConfig).join(", ")} written from what ${prepared.map(({ mode }) => mode.jestConfig).join(", ")} declared, and that config deleted.` + (escaping.length === 0 ? ` Every specifier in the new one is a package name: nothing in it reaches outside this module.` : ` \u26A0\uFE0F ${escaping.length} alias(es) carried from that config reach OUTSIDE this module: ${escaping.slice(0, 3).join(", ")}. They came from its \`moduleNameMapper\` and are kept as they were, but a module that reaches out cannot be moved on its own.`)
   ];
   if (specTypes !== void 0) {
     notes.push(
       `${SPEC_TSCONFIG} now declares \`${VITEST_GLOBAL_TYPES}\` instead of \`jest\`. Without it the module keeps depending on @types/jest and \`jest.Mock\` still resolves, so the migration would look finished while the dependency it cuts is still declared.`
     );
   }
-  notes.push(
-    `run this module's own lint --fix (or its formatter) after installing: the Vitest type imports are written beside the existing ones, and ordering belongs to the tool that enforces it.`
-  );
+  const formatter = writtenFileFormatter(context.cwd);
+  if (formatter !== void 0) {
+    notes.push(
+      `the files this rewrote were run through ${formatter.origin} afterwards. Two things needed it: the Vitest type imports land beside the existing ones, and a rewritten call is often SHORTER than the one it replaced, so the line breaks around it are no longer the ones your config would pick. Neither is a defect, and both would have failed your format check. What no formatter does is ORDER imports, so if your lint enforces \`import/order\`, run its fixer too.`
+    );
+  } else {
+    notes.push(
+      `no style is declared here, by this module or its workspace, so what was written keeps the shape it was written in, and the Vitest type imports sit beside the existing ones rather than where your \`import/order\` wants them. That rule is classified by a prefix list this package cannot read, so it is left to the tool that owns it: run your module's own lint fixer (\`nx run <module>:lint --fix\` here) and its formatter before committing.`
+    );
+  }
   notes.push(
     `then run this module's TYPECHECK, not only its tests. The migration rewrites types as well as calls, and a wrong type is invisible to a green suite: measured on a real module, \`--run --test\` passed while \`--run --typescript\` reported ten errors it had not had before.`
   );
@@ -8308,7 +8595,7 @@ function plan3(context) {
       `${configFile} now imports ${rewrite.moved.join(", ")} from sentinel. Only the import lines changed: every alias, setup file, timeout and coverage path is untouched, so this suite runs what it ran before.`
     );
   }
-  const existing = projectTargets(context.cwd)?.[TEST_SCRIPT_NAME];
+  const existing = projectTargets(context.cwd)?.[TEST_SCRIPT_NAME] ?? manifestTargets(context.cwd)[TEST_SCRIPT_NAME];
   const outputs = existing?.outputs ?? [];
   const dependsOn = existing?.dependsOn ?? [];
   const configurations = existing?.configurations ?? {};
@@ -8363,6 +8650,329 @@ function plan3(context) {
   return { operations, notes };
 }
 
+// src/roles/test/reference.ts
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync as existsSync31, mkdirSync, mkdtempSync, readFileSync as readFileSync29, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join37, resolve as resolve5 } from "node:path";
+
+// src/roles/test/baseline.ts
+function readSnapshot(report) {
+  const files = report?.testResults ?? [];
+  const passing = [];
+  const failing = [];
+  const unloadable = [];
+  for (const file of files) {
+    const assertions = file?.assertionResults ?? [];
+    if (file?.status === "failed" && assertions.length === 0) {
+      unloadable.push(typeof file.name === "string" ? file.name : "an unnamed file");
+    }
+    for (const assertion of assertions) {
+      const name = assertion?.fullName;
+      if (typeof name !== "string" || name === "") continue;
+      if (assertion.status === "passed") passing.push(name);
+      else if (assertion.status === "failed") failing.push(name);
+    }
+  }
+  const claimed = report?.numFailedTests;
+  return {
+    files: files.length,
+    passing: passing.sort(),
+    failing: failing.sort(),
+    unloadable: unloadable.sort(),
+    claimedFailing: typeof claimed === "number" ? claimed : failing.length
+  };
+}
+function difference(left, right) {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const name of right) remaining.set(name, (remaining.get(name) ?? 0) + 1);
+  const missing = [];
+  for (const name of left) {
+    const left_ = remaining.get(name) ?? 0;
+    if (left_ === 0) {
+      missing.push(name);
+      continue;
+    }
+    remaining.set(name, left_ - 1);
+  }
+  return missing.sort();
+}
+var withoutRenderingQuotes = (name) => name.replaceAll(String.raw`\'`, "'").replaceAll(String.raw`\"`, '"').replaceAll(/['"`]\s*\+\s*['"`]/g, "").replaceAll(/(^|[\s:,[{(])(''|"")($|[\s,)\]}])/g, "$1<empty-string>$3").replaceAll(/['"`]/g, "");
+function withoutRenderingNoise(name) {
+  const spelled = withSortedKeys(
+    withoutUndefinedEntries(
+      withoutErrorRendering(
+        withoutNaN(
+          withoutTimestamps(withoutRenderingQuotes(withoutClassBodies(withoutStackFrames(name))))
+        )
+      )
+    )
+  );
+  return withoutArrayBrackets(
+    spelled.replaceAll(/\[\s+/g, "[").replaceAll(/\s+\]/g, "]").replaceAll(/\{\s+/g, "{").replaceAll(/\s+\}/g, "}").replaceAll(/(?<=[[{,\s])\+0\b/g, "0").replaceAll(/:\s+/g, ":").replaceAll(/,\s+/g, ",")
+  );
+}
+function withoutArrayBrackets(name) {
+  return name.replaceAll(
+    /\[([^[\]]*)\]/g,
+    (match, inner) => (
+      // `[Object]` and `[Array]` are the formatter saying it STOPPED, not an array literal.
+      // Stripping their brackets would erase the marker `collapsedOf` pairs on.
+      /^(?:Object|Array)$/.test(inner) ? match : inner.replaceAll(/,\s+/g, ",")
+    )
+  );
+}
+var withoutClassBodies = (name) => name.replaceAll(
+  /class\s+([A-Za-z_$][\w$]*)\s*\{\s*\}/g,
+  (_match, className) => `class ${className}`
+).replaceAll(
+  /class\s+([A-Za-z_$][\w$]*)[\s\S]*?\n\}/g,
+  (_match, className) => `class ${className}`
+);
+var withoutTimestamps = (name) => name.replaceAll(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z/g, "<instant>");
+var withoutNaN = (name) => name.replaceAll(/\bNaN\b/g, "null");
+function entriesOf(inner) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let index = 0; index < inner.length; index += 1) {
+    const character = inner[index];
+    if (character === "[" || character === "(") depth += 1;
+    else if (character === "]" || character === ")") depth -= 1;
+    else if (character === "," && depth === 0) {
+      parts.push(inner.slice(start, index));
+      start = index + 1;
+    }
+    if (depth < 0) return void 0;
+  }
+  if (depth !== 0) return void 0;
+  parts.push(inner.slice(start));
+  return parts.map((part) => part.trim()).filter(Boolean);
+}
+var sortedGroup = (match, inner) => {
+  if (!inner.includes(":")) return match;
+  const parts = entriesOf(inner);
+  if (parts === void 0) return match;
+  if (parts.length < 2 || !parts.every((part) => part.includes(":"))) return match;
+  return `{${[...parts].sort().join(",")}}`;
+};
+var HELD = "\u241F";
+var withSortedKeys = (name) => {
+  const held = [];
+  let current = name;
+  for (let depth = 0; depth < 24; depth += 1) {
+    const next = current.replaceAll(/\{([^{}]*)\}/g, (match, inner) => {
+      held.push(sortedGroup(match, inner));
+      return `${HELD}${held.length - 1}${HELD}`;
+    });
+    if (next === current) break;
+    current = next;
+  }
+  for (let depth = 0; depth < 24 && current.includes(HELD); depth += 1) {
+    current = current.replaceAll(
+      new RegExp(`${HELD}(\\d+)${HELD}`, "g"),
+      (_match, index) => held[Number(index)]
+    );
+  }
+  return current;
+};
+var withoutStackFrames = (name) => {
+  const frame = name.search(/\n\s+at\s/);
+  return frame === -1 ? name : name.slice(0, frame);
+};
+var withoutErrorRendering = (name) => name.replaceAll(/\[[A-Za-z]*(?:Error|Exception):[^\][]*\]/g, "{}");
+var withoutUndefinedEntries = (name) => name.replaceAll(/([{,])\s*[A-Za-z_$][\w$]*\s*:\s*undefined\s*(?=[,}])/g, "$1").replaceAll(/\{\s*,/g, "{").replaceAll(/,\s*\}/g, "}").replaceAll(/\{\s*\}/g, "{}");
+function collapsedOf(candidate, name) {
+  if (!/\[(?:Object|Array)\]/.test(candidate)) return false;
+  const pattern = candidate.split(/\[(?:Object|Array)\]/).map((part) => part.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${pattern}$`, "s").test(name);
+}
+function truncationOf(candidate, name) {
+  const cut = candidate.indexOf("\u2026");
+  if (cut === -1) return false;
+  const head = candidate.slice(0, cut);
+  const tail = candidate.slice(cut + 1);
+  return name.startsWith(head) && name.endsWith(tail);
+}
+function pairRenamed(missing, added) {
+  const remaining = [...added];
+  const renamed = [];
+  const unmatched = [];
+  for (const name of missing) {
+    const normalised = withoutRenderingNoise(name);
+    const at = remaining.findIndex((candidate) => withoutRenderingNoise(candidate) === normalised);
+    if (at === -1) {
+      unmatched.push(name);
+      continue;
+    }
+    renamed.push({ before: name, after: remaining[at] });
+    remaining.splice(at, 1);
+  }
+  const lost = [];
+  for (const name of unmatched) {
+    const normalised = withoutRenderingNoise(name);
+    const at = remaining.findIndex(
+      (candidate) => truncationOf(withoutRenderingNoise(candidate), normalised) || collapsedOf(normalised, withoutRenderingNoise(candidate))
+    );
+    if (at === -1) {
+      lost.push(name);
+      continue;
+    }
+    renamed.push({ before: name, after: remaining[at] });
+    remaining.splice(at, 1);
+  }
+  return { renamed, missing: lost, added: remaining };
+}
+function compareSnapshots(before, after) {
+  const beforeAll = [...before.passing, ...before.failing];
+  const afterAll = [...after.passing, ...after.failing];
+  const paired = pairRenamed(difference(beforeAll, afterAll), difference(afterAll, beforeAll));
+  const renamedBefore = new Set(paired.renamed.map((pair) => pair.before));
+  const regressed = difference(before.passing, after.passing).filter(
+    (name) => !paired.missing.includes(name) && !renamedBefore.has(name)
+  );
+  const failedBefore = new Set(before.failing);
+  const recovered = after.passing.filter((name) => failedBefore.has(name));
+  return {
+    identical: paired.missing.length === 0 && paired.added.length === 0 && regressed.length === 0,
+    missing: paired.missing,
+    added: paired.added,
+    regressed,
+    renamed: paired.renamed,
+    recovered,
+    alreadyFailing: before.failing.length
+  };
+}
+function unusableAsBaseline(snapshot) {
+  if (snapshot.unloadable.length > 0) {
+    return `${snapshot.unloadable.length} file(s) in the reference run did not load, so they reported no test at all and the run is short by however many they hold: ${snapshot.unloadable.slice(0, 3).join(", ")}. A reference that quietly lost tests cannot prove anything about the run after it`;
+  }
+  if (snapshot.claimedFailing > snapshot.failing.length) {
+    return `the reference run says ${snapshot.claimedFailing} test(s) failed and names only ${snapshot.failing.length} of them, so the comparison has nothing to pair the rest against and would report them as invented by the migration`;
+  }
+  if (snapshot.passing.length === 0) {
+    return `the reference run reports no passing test at all, so a green run after would prove nothing: there is no claim to preserve`;
+  }
+  return void 0;
+}
+function renamedExample(before, after) {
+  let shared = 0;
+  while (shared < before.length && shared < after.length && before[shared] === after[shared]) {
+    shared += 1;
+  }
+  const boundary = before.lastIndexOf(" ", shared);
+  const from = boundary > 0 ? boundary + 1 : 0;
+  const ellipsis = from > 0 ? "\u2026" : "";
+  return `"${ellipsis}${before.slice(from)}" -> "${ellipsis}${after.slice(from)}"`;
+}
+function describeComparison(comparison) {
+  const firstRename = comparison.renamed[0];
+  const renamedNote = firstRename === void 0 ? "" : ` ${comparison.renamed.length} test(s) kept their identity and changed name, because the runners render an each title's interpolated value differently (e.g. ${renamedExample(firstRename.before, firstRename.after)}).`;
+  const alreadyRedNote = comparison.alreadyFailing > 0 ? ` ${comparison.alreadyFailing} test(s) were already failing before the migration and are outside this comparison, which covers only what passed.` : "";
+  const recoveredNote = comparison.recovered.length > 0 ? ` ${comparison.recovered.length} test(s) were failing before and pass now.` : "";
+  if (comparison.identical) {
+    return `every test that ran before runs and passes now.${recoveredNote}${renamedNote}${alreadyRedNote}`;
+  }
+  const parts = [];
+  if (comparison.recovered.length > 0) {
+    parts.push(`${comparison.recovered.length} test(s) were failing before and pass now`);
+  }
+  if (comparison.missing.length > 0) {
+    parts.push(
+      `${comparison.missing.length} test(s) no longer exist: ${comparison.missing.slice(0, 3).join(", ")}`
+    );
+  }
+  if (comparison.added.length > 0) {
+    parts.push(
+      `${comparison.added.length} test(s) appeared, which a migration should not do: ${comparison.added.slice(0, 3).join(", ")}`
+    );
+  }
+  if (comparison.regressed.length > 0) {
+    parts.push(
+      `${comparison.regressed.length} test(s) passed before and do not now: ${comparison.regressed.slice(0, 3).join(", ")}`
+    );
+  }
+  return `${parts.join("; ")}.${renamedNote}${alreadyRedNote}`;
+}
+
+// src/roles/test/reference.ts
+function referencePath(cwd) {
+  const key = createHash("sha256").update(resolve5(cwd)).digest("hex").slice(0, 16);
+  return join37(tmpdir(), "sentinel-test-reference", `${key}.json`);
+}
+function runJest(cwd, config) {
+  const bin = resolveBin(cwd, "jest");
+  if (bin === void 0) return void 0;
+  const root = findWorkspaceRoot(cwd) ?? cwd;
+  const out = join37(mkdtempSync(join37(tmpdir(), "sentinel-reference-")), "jest.json");
+  try {
+    execFileSync(bin, ["-c", join37(cwd, config), "--json", `--outputFile=${out}`, "--silent"], {
+      cwd: root,
+      stdio: ["ignore", "ignore", "ignore"],
+      maxBuffer: 1 << 28
+    });
+  } catch {
+  }
+  if (!existsSync31(out)) return void 0;
+  try {
+    return JSON.parse(readFileSync29(out, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function captureReference(cwd, config) {
+  const report = runJest(cwd, config);
+  if (report === void 0) {
+    return {
+      captured: false,
+      message: `could not run jest to record a reference, so this migration cannot be PROVED. It is still applied: a module whose jest run is broken can move, it just cannot be compared.`
+    };
+  }
+  const snapshot = readSnapshot(report);
+  const unusable = unusableAsBaseline(snapshot);
+  if (unusable !== void 0) {
+    return {
+      captured: false,
+      message: `no reference recorded: ${unusable} The migration is applied anyway, unproved.`
+    };
+  }
+  const stored = {
+    runner: "jest",
+    config,
+    takenAt: (/* @__PURE__ */ new Date()).toISOString(),
+    snapshot
+  };
+  const path = referencePath(cwd);
+  mkdirSync(join37(path, ".."), { recursive: true });
+  writeFileSync3(path, `${JSON.stringify(stored, void 0, 2)}
+`);
+  return {
+    captured: true,
+    message: `recorded ${snapshot.passing.length} passing test name(s) from ${config} as the reference. The next \`sentinel --run --test\` compares against it.`
+  };
+}
+function hasReference(cwd) {
+  return existsSync31(referencePath(cwd));
+}
+function compareAgainstReference(cwd, report) {
+  const path = referencePath(cwd);
+  let stored;
+  try {
+    stored = JSON.parse(readFileSync29(path, "utf8"));
+  } catch {
+    rmSync3(path, { force: true });
+    return { ok: true, message: `the recorded reference could not be read, so nothing was proved.` };
+  }
+  const comparison = compareSnapshots(stored.snapshot, readSnapshot(report));
+  if (comparison.identical) rmSync3(path, { force: true });
+  const kept = comparison.identical ? "" : ` The reference is KEPT until a run passes it, so this does not go green by running again. Fix the suite and re-run, or delete ${path} to abandon the proof on purpose.`;
+  return {
+    ok: comparison.identical,
+    message: `${describeComparison(comparison)} (reference: ${stored.config}, ${stored.takenAt})${kept}`
+  };
+}
+
 // src/roles/test/adapters/vitest/vitest.adapter.ts
 function resolveVitest(cwd) {
   const fromSentinel = binFromOwnInstall("vitest", "vitest");
@@ -8370,12 +8980,102 @@ function resolveVitest(cwd) {
   const fromModule = resolveBin(cwd, "vitest");
   return fromModule !== void 0 ? { bin: fromModule, origin: "module" } : { bin: void 0, origin: "module" };
 }
+var FORMATTABLE = /\.(m|c)?(j|t)sx?$|\.json$/;
+var FORMAT_BATCH = 25;
 var VitestAdapter = class extends BaseAdapter {
   target = "test";
   runner = "vitest";
   appliesTo(_preset) {
     return true;
   }
+  /**
+   * Record what this module's tests do TODAY, at the last moment it is still true.
+   *
+   * The plan about to be applied deletes the jest config, and with it any way of asking again. A
+   * migration that cannot be compared to what came before is a migration nobody can check, which
+   * is the whole reason this role has a baseline gate at all.
+   */
+  async beforeInit(ctx) {
+    const adoption = readTestAdoption(ctx.cwd);
+    if (adoption.state !== "jest") return Promise.resolve();
+    const [config] = adoption.jestConfigs;
+    if (config === void 0) return Promise.resolve();
+    this.say(`recording the jest reference before migrating...`);
+    this.say(captureReference(ctx.cwd, config).message);
+    return Promise.resolve();
+  }
+  /**
+   * Hand what was just written to the module's OWN formatter.
+   *
+   * ⚠️ Not a style sentinel imposes: the module adopted `.oxfmtrc.json`, and this runs that
+   * config over the files this role created. Without it, `--init --test` leaves a module whose
+   * own `--run --format` fails on a file the module never wrote.
+   *
+   * Measured on `apps/nest/microservices/agency`, in this repository's CI:
+   *
+   *     agency:format   12 files, including vitest.config.mts and
+   *                     vitest.integration.config.mts, both generated here
+   *
+   * The generator cannot avoid it by wrapping at a fixed width, because the width is the
+   * MODULE's decision: `printWidth` lives in its own config, and 12 modules already set their
+   * own. Guessing it is how a tool starts owning a setting it does not own.
+   *
+   * The same delegation the build role asks a human to do by hand, done.
+   *
+   * ## ⚠️ Two boundaries, both learned by crossing them
+   *
+   * ### Only a module that has a formatter CONFIG
+   *
+   * The question is not "can a formatter be found". It always can: sentinel depends on oxfmt and
+   * ships the binary, so `resolveOxfmt` falls back to its own install and never returns undefined
+   * once sentinel is installed. Asking it that way meant a module with no oxfmt config was
+   * formatted with oxfmt's DEFAULTS, which is a style nobody here chose.
+   *
+   * So the CONFIG is read. A module that wrote its own `.oxfmtrc.json` without adopting the role
+   * has still stated a style, and running it is delegation; running oxfmt with no config is us
+   * choosing one.
+   *
+   * Measured on `apps/nest/microservices/institution`, which has not adopted format and whose lint
+   * forbids semicolons: `institution:lint` went from green to failing, thousands of `semi`, on a
+   * module whose 2958 tests pass. So the adoption is read, not the binary.
+   *
+   * ### Only the files this just WROTE
+   *
+   * `--write .` is a whole-directory pass, and that is not a tidy-up. Same measurement: 1813 files
+   * changed, 47333 insertions, 55506 deletions, in a module whose migration touched 268. A
+   * migration diff is read by a person.
+   *
+   * A module that has not adopted format keeps what was written exactly as written, and is told so.
+   * The codemod rewrites tokens in place, so those files keep the shape they already had.
+   */
+  async afterInit(ctx) {
+    const written = (ctx.written ?? []).filter((file) => FORMATTABLE.test(file));
+    if (written.length === 0) return Promise.resolve();
+    const formatter = writtenFileFormatter(ctx.cwd);
+    if (formatter === void 0) {
+      this.say(
+        `no style is declared here, by this module or its workspace, so the ${written.length} file(s) this wrote keep the shape they were written in. Run your own formatter over them before committing.`
+      );
+      return Promise.resolve();
+    }
+    let failed = 0;
+    for (let at = 0; at < written.length; at += FORMAT_BATCH) {
+      const batch = written.slice(at, at + FORMAT_BATCH);
+      const pass = spawnSync5(formatter.bin, [...formatter.args, ...batch], {
+        cwd: ctx.cwd,
+        encoding: "utf8"
+      });
+      if (pass.status !== 0) failed += batch.length;
+    }
+    this.say(
+      failed === 0 ? `formatted the ${written.length} file(s) this wrote with ${formatter.origin}, so a format check passes on files it did not write itself.` : (
+        // Adoption SUCCEEDED; only the tidy-up did not. Failing here would revert a migration
+        // over a formatting pass, which is the wrong trade.
+        `${formatter.origin} could not run over ${failed} of the ${written.length} file(s) this wrote. Adoption itself is applied; run your formatter before committing.`
+      )
+    );
+    return Promise.resolve();
+  }
   plan(context) {
     return plan3(context);
   }
@@ -8420,15 +9120,36 @@ var VitestAdapter = class extends BaseAdapter {
         `using the MODULE's vitest, not sentinel's. An adopted config gets its plugins from sentinel, and two copies fail in ways that never mention a version. Remove vitest from this module's package.json.`
       );
     }
-    const { options, paths } = splitToolArgs(ctx.cwd, ctx.toolArgs, { valueFlags: [] });
+    const { options: typedOptions, paths: typedPaths } = splitToolArgs(ctx.cwd, ctx.toolArgs, {
+      valueFlags: ["--config", "-c"]
+    });
+    const { cwd: runFrom, options, paths } = fromWorkspaceRoot(ctx.cwd, typedOptions, typedPaths);
     const watching = options.includes("--watch") || options.includes("-w");
-    const argv = watching ? [...options, ...paths] : ["run", ...options, ...paths];
-    const result = spawnSync5(bin, argv, { cwd: ctx.cwd, stdio: "inherit" });
+    const proving = !watching && hasReference(ctx.cwd);
+    const reportFile = proving ? join38(mkdtempSync2(join38(tmpdir2(), "sentinel-run-")), "vitest.json") : void 0;
+    const reporters = reportFile === void 0 ? [] : ["--reporter=default", "--reporter=json", `--outputFile=${reportFile}`];
+    const argv = watching ? [...options, ...paths] : ["run", ...reporters, ...options, ...paths];
+    const result = spawnSync5(bin, argv, { cwd: runFrom, stdio: "inherit" });
     if (result.error) {
       this.say(`could not run vitest (${result.error.message})`);
       return Promise.resolve({ ok: false, code: 1 });
     }
     const code = result.status ?? 1;
+    if (reportFile !== void 0) {
+      let report;
+      try {
+        report = JSON.parse(readFileSync30(reportFile, "utf8"));
+      } catch {
+        report = void 0;
+      }
+      if (report === void 0) {
+        this.say(`vitest wrote no report, so this run proved nothing against the reference.`);
+      } else {
+        const outcome = compareAgainstReference(ctx.cwd, report);
+        this.say(outcome.message);
+        if (!outcome.ok) return Promise.resolve({ ok: false, code: code === 0 ? 1 : code });
+      }
+    }
     return Promise.resolve({ ok: code === 0, code });
   }
   say(message) {
@@ -8436,6 +9157,31 @@ var VitestAdapter = class extends BaseAdapter {
 `);
   }
 };
+function fromWorkspaceRoot(moduleDir, options, paths) {
+  const root = findWorkspaceRoot(moduleDir);
+  if (root === void 0 || root === moduleDir) {
+    return { cwd: moduleDir, options: [...options], paths: [...paths] };
+  }
+  const absolute = (value) => isAbsolute3(value) ? value : resolve6(moduleDir, value);
+  const moved = [];
+  let previousWasConfig = false;
+  for (const option of options) {
+    if (previousWasConfig) {
+      moved.push(absolute(option));
+      previousWasConfig = false;
+      continue;
+    }
+    if (option.startsWith("--config=")) moved.push(`--config=${absolute(option.slice(9))}`);
+    else moved.push(option);
+    previousWasConfig = option === "--config" || option === "-c";
+  }
+  return {
+    cwd: root,
+    // `--root` LAST, so a caller cannot be silently overridden by our own flag.
+    options: [...moved, "--root", moduleDir],
+    paths: paths.map((path) => absolute(path))
+  };
+}
 
 // src/roles/test/register.ts
 function registerTest() {
@@ -8444,10 +9190,10 @@ function registerTest() {
 }
 
 // src/roles/typescript/adapters/tsc/tsc.adapter.ts
-import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync29, readFileSync as readFileSync30 } from "fs";
-import { createRequire as createRequire6 } from "module";
-import { join as join37 } from "path";
+import { spawnSync as spawnSync6 } from "node:child_process";
+import { existsSync as existsSync32, readFileSync as readFileSync32 } from "node:fs";
+import { createRequire as createRequire7 } from "node:module";
+import { join as join40 } from "node:path";
 
 // src/roles/typescript/presets/nest.json
 var nest_default2 = {
@@ -8628,8 +9374,8 @@ function readTsconfigAdoption(cwd) {
 }
 
 // src/roles/typescript/adapters/tsc/plan.ts
-import { readFileSync as readFileSync29 } from "fs";
-import { join as join36 } from "path";
+import { readFileSync as readFileSync31 } from "node:fs";
+import { join as join39 } from "node:path";
 
 // src/roles/typescript/typecheck-script.ts
 var SENTINEL_TYPECHECK_COMMAND = "sentinel --run --typescript";
@@ -8722,7 +9468,7 @@ function planAdoption(context) {
     };
   }
   const existing = parseJsonc(
-    readFileSync29(join36(context.cwd, target.path), "utf8"),
+    readFileSync31(join39(context.cwd, target.path), "utf8"),
     target.path
   );
   const extendsChain = composeExtends(existing.extends, preset);
@@ -8860,7 +9606,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     let chain;
     try {
       const parsed = parseJsonc(
-        readFileSync30(join37(cwd, target.path), "utf8"),
+        readFileSync32(join40(cwd, target.path), "utf8"),
         target.path
       );
       chain = parsed.extends;
@@ -8873,7 +9619,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     );
     if (preset === void 0) return void 0;
     try {
-      createRequire6(join37(cwd, "noop.js")).resolve(preset);
+      createRequire7(join40(cwd, "noop.js")).resolve(preset);
       return void 0;
     } catch {
       return preset;
@@ -8969,7 +9715,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
   referencedProjects(cwd, config) {
     try {
       const parsed = parseJsonc(
-        readFileSync30(join37(cwd, config), "utf8"),
+        readFileSync32(join40(cwd, config), "utf8"),
         config
       );
       const referenced = (parsed.references ?? []).map((reference) => reference.path).filter((path) => typeof path === "string" && path.length > 0);
@@ -8985,7 +9731,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
    * check.
    */
   typecheckTarget(cwd) {
-    if (existsSync29(join37(cwd, "tsconfig.json"))) return "tsconfig.json";
+    if (existsSync32(join40(cwd, "tsconfig.json"))) return "tsconfig.json";
     const target = resolveTsconfigTarget(cwd);
     return target.reason === "none" ? null : target.path;
   }
@@ -9134,7 +9880,7 @@ function detectFramework(packageJson) {
 }
 
 // src/core/dispatch.ts
-import { basename as basename3 } from "path";
+import { basename as basename3 } from "node:path";
 
 // src/shared/text.ts
 function ensureLines(current, lines) {
@@ -9190,8 +9936,8 @@ function replaceLines(current, replacements) {
 }
 
 // src/core/apply-plan.ts
-import { existsSync as existsSync30, readFileSync as readFileSync31, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve5, sep } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync33, renameSync, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { resolve as resolve7, sep } from "node:path";
 import { applyEdits as applyEdits3, findNodeAtLocation, modify, parseTree } from "jsonc-parser";
 
 // src/shared/deep-merge.ts
@@ -9201,15 +9947,15 @@ function isPlainObject(value) {
 
 // src/core/apply-plan.ts
 function resolveWithinRoot(cwd, relativePath) {
-  const root = resolve5(cwd);
-  const absolutePath = resolve5(root, relativePath);
+  const root = resolve7(cwd);
+  const absolutePath = resolve7(root, relativePath);
   if (absolutePath !== root && !absolutePath.startsWith(root + sep)) {
     throw new Error(`Refusing to write outside the module root: "${relativePath}".`);
   }
   return absolutePath;
 }
 function readIfExists(absolutePath) {
-  return existsSync30(absolutePath) ? readFileSync31(absolutePath, "utf8") : void 0;
+  return existsSync33(absolutePath) ? readFileSync33(absolutePath, "utf8") : void 0;
 }
 function* leaves(value, prefix = []) {
   for (const [key, keyValue] of Object.entries(value)) {
@@ -9311,14 +10057,14 @@ function preparePlan(cwd, plan4) {
 }
 function writeFileAtomic(absolutePath, contents) {
   const tempPath = `${absolutePath}.sentinel-${process.pid}.tmp`;
-  writeFileSync3(tempPath, contents);
+  writeFileSync4(tempPath, contents);
   renameSync(tempPath, absolutePath);
 }
 function applyPlan(cwd, plan4) {
   const changed = preparePlan(cwd, plan4).filter((file) => file.before !== file.after);
   for (const file of changed) {
     if (file.deleted) {
-      rmSync3(file.absolutePath, { force: true });
+      rmSync4(file.absolutePath, { force: true });
       continue;
     }
     writeFileAtomic(file.absolutePath, file.after);
@@ -9327,8 +10073,8 @@ function applyPlan(cwd, plan4) {
 }
 
 // src/core/config/preset-evidence.ts
-import { existsSync as existsSync31, readdirSync as readdirSync8, readFileSync as readFileSync32 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync34, readdirSync as readdirSync9, readFileSync as readFileSync34 } from "node:fs";
+import { join as join41 } from "node:path";
 var PATH_SIGNALS = [
   {
     preset: "nest",
@@ -9356,18 +10102,18 @@ function sourceImports(cwd, pattern) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = readdirSync8(dir, { withFileTypes: true });
+      entries = readdirSync9(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        if (!NOT_SCANNED.has(entry.name)) stack.push(join38(dir, entry.name));
+        if (!NOT_SCANNED.has(entry.name)) stack.push(join41(dir, entry.name));
         continue;
       }
       if (!SOURCE_FILE2.test(entry.name)) continue;
       try {
-        if (pattern.test(readFileSync32(join38(dir, entry.name), "utf8"))) return true;
+        if (pattern.test(readFileSync34(join41(dir, entry.name), "utf8"))) return true;
       } catch {
         continue;
       }
@@ -9376,11 +10122,11 @@ function sourceImports(cwd, pattern) {
   return false;
 }
 function dependencyNames(cwd) {
-  const path = join38(cwd, "package.json");
-  if (!existsSync31(path)) return [];
+  const path = join41(cwd, "package.json");
+  if (!existsSync34(path)) return [];
   try {
     const manifest = parseJsonc(
-      readFileSync32(path, "utf8"),
+      readFileSync34(path, "utf8"),
       path
     );
     return [
@@ -9394,7 +10140,7 @@ function dependencyNames(cwd) {
 function declaresJsx(cwd) {
   let entries;
   try {
-    entries = readdirSync8(cwd).filter(
+    entries = readdirSync9(cwd).filter(
       (name) => name.startsWith("tsconfig") && name.endsWith(".json")
     );
   } catch {
@@ -9403,7 +10149,7 @@ function declaresJsx(cwd) {
   for (const name of entries) {
     try {
       const config = parseJsonc(
-        readFileSync32(join38(cwd, name), "utf8"),
+        readFileSync34(join41(cwd, name), "utf8"),
         name
       );
       if (config.compilerOptions?.jsx !== void 0) return true;
@@ -9548,9 +10294,20 @@ async function dispatch(opts) {
   if (opts.dryRun) {
     return previewPlan(opts, plan4);
   }
+  if (adapter.beforeInit) {
+    await adapter.beforeInit({
+      module: basename3(opts.cwd),
+      cwd: opts.cwd,
+      preset,
+      ci: false,
+      fix: false
+    });
+  }
+  const written = [];
   for (const change of applyPlan(opts.cwd, plan4)) {
     process.stderr.write(`  ${change.deleted ? "removed" : "wrote"} ${change.path}
 `);
+    if (!change.deleted) written.push(change.path);
   }
   for (const note of plan4.notes ?? []) process.stderr.write(`  ${note}
 `);
@@ -9562,7 +10319,8 @@ async function dispatch(opts) {
       cwd: opts.cwd,
       preset,
       ci: false,
-      fix: true
+      fix: true,
+      written
     });
   }
   return 0;
@@ -9591,4 +10349,3 @@ export {
   detectFramework,
   dispatch
 };
-//# sourceMappingURL=chunk-4UIZJ3TR.js.map