@noir-ai/create 1.18.0 → 1.19.0

package/dist/index.d.ts

@@ -391,6 +391,9 @@ type BuildManifestContext = {
      *  .prettierignore only for JS; .dockerignore only when a Dockerfile is
      *  present; an unknown/empty stack ⇒ all four, for backward compat). */
     stack?: StackInfo;
+    /** Compiled project baseline (stack + canonical commands + entry points),
+     *  rendered into the `.noir/NOIR.md` brief block as `{{baseline}}`. */
+    baseline?: string;
     /** The `rules.enabled` switch from the project's `.noir/config.yml`. False
      *  drops the working-rules seed from the manifest, so no command emits or
      *  backfills `.noir/rules/RULES.md` for a project that opted out. Undefined
@@ -706,6 +709,9 @@ interface ScaffoldOptions {
     /** Preview: compute the same written/skipped/migrated lists without touching
      *    disk. `noir doctor`/CI use this to report drift. */
     dryRun?: boolean;
+    /** Drift check: a dry-run that reports only what would CHANGE (byte comparison,
+     *  not the full planned-emit list). Used by `noir sync --check`. */
+    check?: boolean;
     /** Policy for a `regenerate` file that exists and DIFFERS from the
      *    template, when no {@link onConflict} callback is provided. Default
      *    `'overwrite'` is byte-backward-compatible. `'preserve'` keeps the user's
@@ -884,8 +890,10 @@ declare function scaffold(opts: ScaffoldOptions): Promise<ScaffoldResult>;
  *  whenever a manifest entry, template, or migration changes shape. 1.3.0 adds
  *  the migration that points a joined repo's MCP entry back at the workspace
  *  bridge; 1.4.0 adds the migration that moves the SessionStart hook command off
- *  the `.mjs` runner and onto `noir hook` (see migrations/index.ts). */
-declare const CURRENT_SCAFFOLD_VERSION = "1.4.0";
+ *  the `.mjs` runner and onto `noir hook`; 1.5.0 adds the migration that appends
+ *  the enforcement events to an existing claude hook and backfills the gemini
+ *  hook (see migrations/index.ts). */
+declare const CURRENT_SCAFFOLD_VERSION = "1.5.0";
 /** Path to the stamp file under `root`. Exposed for tests + doctor. */
 declare function scaffoldVersionPath(root: string): string;
 /** Read the applied scaffold version, or `null` if the stamp is absent/unparseable.

package/dist/index.js

@@ -315,40 +315,8 @@ function buildHostArtifacts(adapter, ctx) {
       description: workspace !== null ? `${host} MCP server pointer (workspace "${workspace}")` : `${host} MCP server pointer`
     });
   }
-  if (host === "claude") {
-    const HOOK_DEDUP = " hook";
-    const hookEntry = {
-      hooks: {
-        SessionStart: [
-          {
-            hooks: [
-              {
-                type: "command",
-                command: `"${ctx.command}" hook`
-              }
-            ]
-          }
-        ],
-        SubagentStart: [
-          {
-            hooks: [
-              {
-                type: "command",
-                command: `"${ctx.command}" hook`
-              }
-            ]
-          }
-        ]
-      }
-    };
-    entries.push({
-      path: ".claude/settings.local.json",
-      mode: "mergeJson",
-      host,
-      content: JSON.stringify(hookEntry, null, 2),
-      dedupSubstring: HOOK_DEDUP,
-      description: "SessionStart + SubagentStart hook entry (user-owned, written once)"
-    });
+  const hookEmissions = adapter.emitHooks?.({ command: ctx.command }) ?? null;
+  if (hookEmissions !== null) {
     entries.push({
       path: ".noir/router.md",
       mode: "managedBlock",
@@ -366,6 +334,18 @@ function buildHostArtifacts(adapter, ctx) {
         description: "always-on anti-slop + laziness ruleset (hook-injected, not @imported)"
       });
     }
+    for (const emission of hookEmissions) {
+      const json = JSON.stringify(emission.content, null, 2);
+      entries.push({
+        path: emission.path,
+        mode: emission.mode,
+        host,
+        content: emission.mode === "regenerate" ? `${json}
+` : json,
+        ...emission.dedupSubstring !== void 0 ? { dedupSubstring: emission.dedupSubstring } : {},
+        description: emission.description
+      });
+    }
   }
   return entries;
 }
@@ -531,6 +511,7 @@ import { mcpConfigPathFor, noirStdioArgs, TRANSPORT_KEYS } from "@noir-ai/adapte
 import {
   atomicWriteFile as atomicWriteFile2,
   loadProjectInfo,
+  readProjectConfig,
   readWorkspaceMarker as readWorkspaceMarker2,
   resolveNoirCommand
 } from "@noir-ai/core";
@@ -1287,12 +1268,98 @@ var hookCommand = {
     return result;
   }
 };
+function applyHookEvents(ctx, rel, abs, events, createIfMissing) {
+  let settings;
+  if (!existsSync4(abs)) {
+    if (!createIfMissing) {
+      return { note: `${rel}: absent \u2014 nothing to migrate`, changed: false, conflict: false };
+    }
+    settings = {};
+  } else {
+    try {
+      settings = JSON.parse(readFileSync4(abs, "utf8"));
+    } catch (err) {
+      return {
+        note: `${rel}: unreadable (${errorMessage(err)}) \u2014 left untouched`,
+        changed: false,
+        conflict: true
+      };
+    }
+  }
+  const existing = settings.hooks;
+  if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
+    if (!createIfMissing) {
+      return {
+        note: `${rel}: no hooks object \u2014 nothing to migrate`,
+        changed: false,
+        conflict: false
+      };
+    }
+    settings.hooks = {};
+  }
+  const hooksObj = settings.hooks;
+  let added = false;
+  for (const [event, patch] of Object.entries(events)) {
+    if (hooksObj[event] === void 0) {
+      hooksObj[event] = patch;
+      added = true;
+    }
+  }
+  if (!added) {
+    return { note: `${rel}: enforcement events already present`, changed: false, conflict: false };
+  }
+  if (ctx.dryRun) {
+    return { note: `${rel}: would append enforcement events`, changed: true, conflict: false };
+  }
+  try {
+    atomicWriteFile2(abs, `${JSON.stringify(settings, null, 2)}
+`);
+    return { note: `${rel}: appended enforcement events`, changed: true, conflict: false };
+  } catch (err) {
+    return {
+      note: `${rel}: write failed (${errorMessage(err)}) \u2014 left untouched`,
+      changed: false,
+      conflict: true
+    };
+  }
+}
+var hookEvents = {
+  from: "1.4.0",
+  to: "1.5.0",
+  description: "append the enforcement hook events to the claude or gemini hook",
+  run: (ctx) => {
+    const result = { changed: [], conflicts: [], notes: [] };
+    const host = readProjectConfig(ctx.root)?.host ?? "claude";
+    if (host !== "claude" && host !== "gemini") {
+      result.notes.push(
+        `${host}: no hook migration needed (cursor is regenerate-mode; opencode/agents-md have no hook surface)`
+      );
+      return result;
+    }
+    const rel = host === "gemini" ? ".gemini/settings.json" : ".claude/settings.local.json";
+    const abs = join5(ctx.root, ...rel.split("/"));
+    const command = host === "gemini" ? `"${resolveNoirCommand()}" hook --host gemini` : `"${resolveNoirCommand()}" hook`;
+    const events = host === "gemini" ? {
+      SessionStart: [{ hooks: [{ type: "command", command }] }],
+      BeforeTool: [{ matcher: ".*", hooks: [{ type: "command", command }] }]
+    } : {
+      PreToolUse: [{ hooks: [{ type: "command", command }] }],
+      Stop: [{ hooks: [{ type: "command", command }] }]
+    };
+    const out = applyHookEvents(ctx, rel, abs, events, host === "gemini");
+    if (out.conflict) result.conflicts.push(rel);
+    else if (out.changed) result.changed.push(rel);
+    result.notes.push(out.note);
+    return result;
+  }
+};
 var MIGRATIONS = [
   synthetic,
   envPointer,
   envTemplates,
   workspaceBridge,
-  hookCommand
+  hookCommand,
+  hookEvents
 ];
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -1312,31 +1379,107 @@ function applyWithConflict(ours, theirs, path) {
 }
 
 // src/scaffold.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync7, renameSync as renameSync2, rmSync as rmSync3 } from "fs";
-import { basename as basename2, dirname as dirname5, join as join8 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync8, renameSync as renameSync2, rmSync as rmSync3 } from "fs";
+import { basename as basename2, dirname as dirname5, join as join9 } from "path";
 import {
   createProjectId,
   loadProjectInfo as loadProjectInfo2,
   paths as paths2,
   readManagedBlock,
-  readProjectConfig,
+  readProjectConfig as readProjectConfig2,
   resolveNoirCommand as resolveNoirCommand2,
   sha256Hex12
 } from "@noir-ai/core";
 
+// src/baseline.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
+var COMMAND_KEYS = [
+  ["build", "build"],
+  ["test", "test"],
+  ["lint", "lint"],
+  ["typecheck", "typecheck"],
+  ["format", "format"],
+  ["start", "start"],
+  ["dev", "dev"]
+];
+var ENTRY_POINTS = [
+  "src/index.ts",
+  "src/index.tsx",
+  "src/index.js",
+  "src/index.jsx",
+  "src/main.ts",
+  "src/main.js",
+  "src/main.py",
+  "main.ts",
+  "main.js",
+  "main.py",
+  "app/main.py",
+  "src/app.py",
+  "cmd/main.go",
+  "src/lib.rs",
+  "src/main.rs"
+];
+function detectCommands(root) {
+  const out = {};
+  const pjPath = join6(root, "package.json");
+  if (existsSync5(pjPath)) {
+    let pj;
+    try {
+      pj = JSON.parse(readFileSync5(pjPath, "utf8"));
+    } catch {
+      pj = void 0;
+    }
+    for (const [name, key] of COMMAND_KEYS) {
+      const value = pj?.scripts?.[key];
+      if (typeof value === "string" && value !== "") out[name] = value;
+    }
+  }
+  const makefile = join6(root, "Makefile");
+  if (existsSync5(makefile)) {
+    try {
+      const raw = readFileSync5(makefile, "utf8");
+      for (const name of ["build", "test", "lint"]) {
+        if (!(name in out) && new RegExp(`^${name}:`, "m").test(raw)) out[name] = `make ${name}`;
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+function detectEntryPoints(root) {
+  return ENTRY_POINTS.filter((p) => existsSync5(join6(root, p)));
+}
+function renderBaseline(stack, commands, entryPoints) {
+  const lang = stack.languages.length > 0 ? stack.languages.join(", ") : "unknown";
+  const framework = stack.frameworks.length > 0 ? ` (${stack.frameworks.join(", ")})` : "";
+  const lines = [
+    `- **Stack:** ${lang}${framework}${stack.monorepo ? " (monorepo)" : ""}`,
+    `- **Package manager:** ${stack.packageManager ?? "none"}`
+  ];
+  if (stack.ci) lines.push(`- **CI:** ${stack.ci}`);
+  const entries = Object.entries(commands);
+  if (entries.length > 0) {
+    lines.push("- **Commands:**");
+    for (const [name, command] of entries) lines.push(`  - \`${name}\`: \`${command}\``);
+  }
+  if (entryPoints.length > 0) lines.push(`- **Entry points:** ${entryPoints.join(", ")}`);
+  return lines.join("\n");
+}
+
 // src/scaffold-version.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname4, join as join6 } from "path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname4, join as join7 } from "path";
 import { NOIR_DIR as NOIR_DIR2 } from "@noir-ai/core";
-var CURRENT_SCAFFOLD_VERSION = "1.4.0";
+var CURRENT_SCAFFOLD_VERSION = "1.5.0";
 var PREFIX = "noir-scaffold=";
 function scaffoldVersionPath(root) {
-  return join6(root, NOIR_DIR2, "scaffold-version");
+  return join7(root, NOIR_DIR2, "scaffold-version");
 }
 function readScaffoldVersion(root) {
   let raw;
   try {
-    raw = readFileSync5(scaffoldVersionPath(root), "utf8");
+    raw = readFileSync6(scaffoldVersionPath(root), "utf8");
   } catch {
     return null;
   }
@@ -1357,8 +1500,8 @@ function writeScaffoldVersion(root, version) {
 }
 
 // src/stack-detect.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync7 } from "fs";
+import { join as join8 } from "path";
 var NODE_FRAMEWORKS = [
   ["next", "next"],
   ["vite", "vite"],
@@ -1385,7 +1528,7 @@ var PYTHON_FRAMEWORKS = [
 ];
 function readJson(file) {
   try {
-    return JSON.parse(readFileSync6(file, "utf8"));
+    return JSON.parse(readFileSync7(file, "utf8"));
   } catch {
     return void 0;
   }
@@ -1395,11 +1538,11 @@ function detectStack(root) {
   const frameworks = /* @__PURE__ */ new Set();
   let monorepo = false;
   let packageManager = null;
-  const pjPath = join7(root, "package.json");
-  if (existsSync5(pjPath)) {
+  const pjPath = join8(root, "package.json");
+  if (existsSync6(pjPath)) {
     const pj = readJson(pjPath);
     if (pj) {
-      const hasTs = Boolean(pj.devDependencies?.typescript) || existsSync5(join7(root, "tsconfig.json"));
+      const hasTs = Boolean(pj.devDependencies?.typescript) || existsSync6(join8(root, "tsconfig.json"));
       languages.add(hasTs ? "typescript" : "javascript");
       const deps = /* @__PURE__ */ new Set([
         ...Object.keys(pj.dependencies ?? {}),
@@ -1418,22 +1561,22 @@ function detectStack(root) {
       }
     }
   }
-  if (existsSync5(join7(root, "pnpm-workspace.yaml"))) {
+  if (existsSync6(join8(root, "pnpm-workspace.yaml"))) {
     monorepo = true;
     packageManager = packageManager ?? "pnpm";
   }
-  if (existsSync5(join7(root, "turbo.json")) || existsSync5(join7(root, "nx.json"))) {
+  if (existsSync6(join8(root, "turbo.json")) || existsSync6(join8(root, "nx.json"))) {
     monorepo = true;
   }
   if (!packageManager) {
-    if (existsSync5(join7(root, "pnpm-lock.yaml"))) packageManager = "pnpm";
-    else if (existsSync5(join7(root, "yarn.lock"))) packageManager = "yarn";
-    else if (existsSync5(join7(root, "package-lock.json"))) packageManager = "npm";
+    if (existsSync6(join8(root, "pnpm-lock.yaml"))) packageManager = "pnpm";
+    else if (existsSync6(join8(root, "yarn.lock"))) packageManager = "yarn";
+    else if (existsSync6(join8(root, "package-lock.json"))) packageManager = "npm";
   }
-  if (existsSync5(join7(root, "pyproject.toml")) || existsSync5(join7(root, "requirements.txt")) || existsSync5(join7(root, "Pipfile")) || existsSync5(join7(root, "setup.py"))) {
+  if (existsSync6(join8(root, "pyproject.toml")) || existsSync6(join8(root, "requirements.txt")) || existsSync6(join8(root, "Pipfile")) || existsSync6(join8(root, "setup.py"))) {
     languages.add("python");
-    if (existsSync5(join7(root, "pyproject.toml"))) {
-      const raw = safeRead(join7(root, "pyproject.toml"));
+    if (existsSync6(join8(root, "pyproject.toml"))) {
+      const raw = safeRead(join8(root, "pyproject.toml"));
       if (raw) {
         for (const [dep, id] of PYTHON_FRAMEWORKS) {
           if (pyprojectHasDep(raw, dep)) frameworks.add(id);
@@ -1441,13 +1584,13 @@ function detectStack(root) {
       }
     }
   }
-  if (existsSync5(join7(root, "go.mod"))) {
+  if (existsSync6(join8(root, "go.mod"))) {
     languages.add("go");
     packageManager = packageManager ?? "go-modules";
   }
-  if (existsSync5(join7(root, "Cargo.toml"))) {
+  if (existsSync6(join8(root, "Cargo.toml"))) {
     languages.add("rust");
-    const raw = safeRead(join7(root, "Cargo.toml"));
+    const raw = safeRead(join8(root, "Cargo.toml"));
     if (raw) {
       if (/^\s*actix-web\b/m.test(raw)) frameworks.add("actix-web");
       if (/^\s*actix\s*=/m.test(raw)) frameworks.add("actix");
@@ -1459,7 +1602,7 @@ function detectStack(root) {
   let pmSource = "unknown";
   let pmConflict = false;
   if (packageManager) {
-    if (pjPath && existsSync5(pjPath)) {
+    if (pjPath && existsSync6(pjPath)) {
       const pj = readJson(pjPath);
       if (pj?.packageManager?.split("@")[0] === packageManager) {
         pmSource = "packageManager-field";
@@ -1488,10 +1631,10 @@ function detectStack(root) {
     }
   }
   let ci = null;
-  if (existsSync5(join7(root, ".github", "workflows"))) ci = "github";
-  else if (existsSync5(join7(root, ".gitlab-ci.yml"))) ci = "gitlab";
-  else if (existsSync5(join7(root, ".circleci", "config.yml"))) ci = "circleci";
-  else if (existsSync5(join7(root, "Jenkinsfile"))) ci = "jenkins";
+  if (existsSync6(join8(root, ".github", "workflows"))) ci = "github";
+  else if (existsSync6(join8(root, ".gitlab-ci.yml"))) ci = "gitlab";
+  else if (existsSync6(join8(root, ".circleci", "config.yml"))) ci = "circleci";
+  else if (existsSync6(join8(root, "Jenkinsfile"))) ci = "jenkins";
   const aiFiles = [
     ["AGENTS.md", "agents-md"],
     ["CLAUDE.md", "claude"],
@@ -1501,12 +1644,12 @@ function detectStack(root) {
   ];
   const existingAiFiles = [];
   for (const [p, kind] of aiFiles) {
-    const full = join7(root, p);
-    if (existsSync5(full)) existingAiFiles.push({ path: p, kind });
+    const full = join8(root, p);
+    if (existsSync6(full)) existingAiFiles.push({ path: p, kind });
   }
-  const cursorRulesDir = join7(root, ".cursor", "rules");
+  const cursorRulesDir = join8(root, ".cursor", "rules");
   try {
-    if (existsSync5(cursorRulesDir)) {
+    if (existsSync6(cursorRulesDir)) {
       const entries = readdirSync2(cursorRulesDir);
       for (const e of entries) {
         if (e.endsWith(".md"))
@@ -1528,7 +1671,7 @@ function detectStack(root) {
 }
 function safeRead(file) {
   try {
-    return readFileSync6(file, "utf8");
+    return readFileSync7(file, "utf8");
   } catch {
     return void 0;
   }
@@ -1562,10 +1705,10 @@ function assertSafeRoot(root) {
 }
 function envOwnerOnly(opts) {
   if (opts.dryRun === true) return void 0;
-  return ensureOwnerOnly(join8(paths2.noirDir(opts.root), ".env"));
+  return ensureOwnerOnly(join9(paths2.noirDir(opts.root), ".env"));
 }
 function readConfiguredHost(root) {
-  if (!existsSync6(paths2.config(root))) return "claude";
+  if (!existsSync7(paths2.config(root))) return "claude";
   try {
     return loadProjectInfo2(root).config.host;
   } catch {
@@ -1573,7 +1716,7 @@ function readConfiguredHost(root) {
   }
 }
 function readConfiguredRulesEnabled(root) {
-  return readProjectConfig(root)?.rules.enabled ?? true;
+  return readProjectConfig2(root)?.rules.enabled ?? true;
 }
 async function scaffold(opts) {
   assertSafeRoot(opts.root);
@@ -1592,6 +1735,7 @@ async function scaffold(opts) {
   }
   const fromVersion = readScaffoldVersion(opts.root);
   const stack = detectStack(opts.root);
+  const baseline = renderBaseline(stack, detectCommands(opts.root), detectEntryPoints(opts.root));
   const ancestors = readAncestors(opts.root);
   const mergeManagedRegions = opts.mergeManagedRegions !== false;
   const hasIdentity = fromVersion !== null || idFile.state === "valid";
@@ -1660,7 +1804,8 @@ async function scaffold(opts) {
     host,
     transport,
     url: opts.url,
-    command
+    command,
+    baseline
   };
   const written = [];
   const skipped = [];
@@ -1681,10 +1826,26 @@ async function scaffold(opts) {
   };
   const groups = groupApplicableByPath(manifest, host, emitContext);
   for (const [relPath, entries] of groups) {
-    const abs = join8(opts.root, relPath);
+    const abs = join9(opts.root, relPath);
     const managed = entries.filter((e) => e.mode === "managedBlock");
     if (managed.length >= 2) {
       if (opts.dryRun) {
+        if (opts.check === true) {
+          const onDisk2 = readOptional(abs);
+          const regions2 = managed.map((e) => {
+            const block = e.block;
+            if (!block) {
+              throw new Error(`manifest entry ${e.path}: managedBlock mode missing 'block'`);
+            }
+            const theirs = buildRegion(block, renderEntry(e, vars));
+            const merged = mergeManagedRegions ? mergeManagedRegion(abs, e.path, block, theirs, ancestors) : { text: theirs, conflict: false, cleanTheirs: theirs };
+            return { block, regionText: merged.text };
+          });
+          const predicted2 = predictManagedBlocks(onDisk2 ?? "", regions2);
+          if (onDisk2 !== void 0 && predicted2 === onDisk2) identical.push(relPath);
+          else written.push(relPath);
+          continue;
+        }
         written.push(relPath);
         continue;
       }
@@ -1732,13 +1893,32 @@ async function scaffold(opts) {
     if (!opts.dryRun) mkdirSync3(dirname5(abs), { recursive: true });
     for (const entry of entries) {
       if (opts.dryRun) {
+        if (opts.check === true && (entry.mode === "regenerate" || entry.mode === "managedBlock")) {
+          const body2 = renderEntry(entry, vars);
+          const onDisk = readOptional(abs);
+          if (entry.mode === "regenerate") {
+            if (onDisk === void 0 || onDisk !== body2) written.push(entry.path);
+            else identical.push(entry.path);
+          } else {
+            const block = entry.block;
+            if (!block) {
+              throw new Error(`manifest entry ${entry.path}: managedBlock mode missing 'block'`);
+            }
+            const theirs = buildRegion(block, body2);
+            const merged = mergeManagedRegions ? mergeManagedRegion(abs, entry.path, block, theirs, ancestors) : { text: theirs, conflict: false, cleanTheirs: theirs };
+            const predicted = predictManagedBlock(onDisk ?? "", block, merged.text);
+            if (onDisk !== void 0 && predicted === onDisk) identical.push(entry.path);
+            else written.push(entry.path);
+          }
+          continue;
+        }
         if (entry.mode !== "skipIfExists") {
           written.push(entry.path);
           continue;
         }
         const seedKind = refreshableSeedKind(entry, emitContext);
         if (seedKind === void 0) {
-          if (existsSync6(abs)) {
+          if (existsSync7(abs)) {
             skipped.push(entry.path);
           } else {
             written.push(entry.path);
@@ -1931,7 +2111,7 @@ async function resolveManagedConflict(relPath, mode, opts) {
 function readProjectIdFile(root) {
   let raw;
   try {
-    raw = readFileSync7(paths2.projectId(root), "utf8");
+    raw = readFileSync8(paths2.projectId(root), "utf8");
   } catch {
     return { state: "absent", id: null };
   }
@@ -1971,7 +2151,7 @@ function refreshableSeedKind(entry, emitContext) {
 async function writeWithConflict(abs, relPath, proposed, opts, internals) {
   let existing;
   try {
-    existing = readFileSync7(abs, "utf8");
+    existing = readFileSync8(abs, "utf8");
   } catch {
     existing = void 0;
   }
@@ -2032,7 +2212,7 @@ function uniqueAside(abs, relPath, suffix) {
     rel: `${relPath}${s}`
   });
   let candidate = make(suffix);
-  for (let n = 1; existsSync6(candidate.abs); n++) candidate = make(`${suffix}.${n}`);
+  for (let n = 1; existsSync7(candidate.abs); n++) candidate = make(`${suffix}.${n}`);
   return candidate;
 }
 function groupApplicableByPath(manifest, host, emitContext) {
@@ -2052,7 +2232,7 @@ function isNoirMdPath(relPath) {
 function healLegacyNoirMd(absPath) {
   let content;
   try {
-    content = readFileSync7(absPath, "utf8");
+    content = readFileSync8(absPath, "utf8");
   } catch {
     return;
   }
@@ -2068,7 +2248,7 @@ function renderEntry(entry, vars) {
 }
 function readOptional(absPath) {
   try {
-    return readFileSync7(absPath, "utf8");
+    return readFileSync8(absPath, "utf8");
   } catch (err) {
     if (err instanceof Error && err.code === "ENOENT") {
       return void 0;