@noir-ai/create 1.19.0 → 1.19.1

package/dist/index.js

@@ -30,19 +30,215 @@ function writeAncestors(root, map) {
   writeFileSync(path, next, "utf8");
 }
 
+// src/hooks.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+import { resolveAdapter } from "@noir-ai/adapters";
+import { resolveNoirCommand } from "@noir-ai/core";
+
+// src/writers.ts
+import {
+  closeSync,
+  existsSync as existsSync2,
+  openSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmSync,
+  writeSync
+} from "fs";
+import { basename, dirname as dirname2, join as join2 } from "path";
+import { atomicWriteFile, stripManagedBlock, writeManagedRegion } from "@noir-ai/core";
+import { ensureOwnerOnly } from "@noir-ai/core";
+function regenerate(absPath, content) {
+  const dir = dirname2(absPath);
+  const tmp = join2(
+    dir,
+    `.${basename(absPath)}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`
+  );
+  let fd;
+  try {
+    fd = openSync(tmp, "w");
+    writeSync(fd, content, 0, "utf8");
+    closeSync(fd);
+    fd = void 0;
+    renameSync(tmp, absPath);
+  } finally {
+    if (fd !== void 0) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+  }
+  return { path: absPath, mode: "regenerate", written: true };
+}
+function managedBlock(absPath, block, regionText) {
+  writeManagedRegion(absPath, block, regionText);
+  return { path: absPath, mode: "managedBlock", written: true };
+}
+function managedBlocks(absPath, regions) {
+  if (regions.length === 0) {
+    throw new Error("managedBlocks requires at least one region");
+  }
+  if (regions.length === 1) {
+    const only = regions[0];
+    if (!only) throw new Error("managedBlocks: undefined region");
+    return managedBlock(absPath, only.block, only.regionText);
+  }
+  let content = "";
+  try {
+    content = readFileSync2(absPath, "utf8");
+  } catch {
+  }
+  let stripped = content;
+  for (const r of regions) {
+    stripped = stripManagedBlock(stripped, r.block);
+  }
+  const regionsJoined = regions.map((r) => r.regionText).join("\n");
+  const next = stripped.trim().length > 0 ? `${stripped.trimEnd()}
+
+${regionsJoined}` : regionsJoined;
+  atomicWriteFile(absPath, next);
+  return { path: absPath, mode: "managedBlock", written: true };
+}
+function buildRegion(block, body) {
+  return `${block.begin}
+${body.trimEnd()}
+${block.end}
+`;
+}
+function predictManagedBlock(currentContent, block, regionText) {
+  const stripped = stripManagedBlock(currentContent, block);
+  return stripped ? `${stripped.trimEnd()}
+
+${regionText}` : regionText;
+}
+function predictManagedBlocks(currentContent, regions) {
+  if (regions.length === 0) {
+    throw new Error("predictManagedBlocks requires at least one region");
+  }
+  if (regions.length === 1) {
+    const only = regions[0];
+    if (!only) throw new Error("predictManagedBlocks: undefined region");
+    return predictManagedBlock(currentContent, only.block, only.regionText);
+  }
+  let stripped = currentContent;
+  for (const r of regions) {
+    stripped = stripManagedBlock(stripped, r.block);
+  }
+  const regionsJoined = regions.map((r) => r.regionText).join("\n");
+  return stripped.trim().length > 0 ? `${stripped.trimEnd()}
+
+${regionsJoined}` : regionsJoined;
+}
+function skipIfExists(absPath, content, fileMode) {
+  if (existsSync2(absPath)) {
+    return { path: absPath, mode: "skipIfExists", written: false };
+  }
+  atomicWriteFile(absPath, content, fileMode !== void 0 ? { mode: fileMode } : {});
+  return { path: absPath, mode: "skipIfExists", written: true };
+}
+function refreshSeed(absPath, content) {
+  atomicWriteFile(absPath, content);
+  return { path: absPath, mode: "skipIfExists", written: true };
+}
+function mergeJson(absPath, patch, dedupSubstring, force) {
+  let existing = {};
+  if (existsSync2(absPath)) {
+    try {
+      existing = JSON.parse(readFileSync2(absPath, "utf8"));
+    } catch {
+      existing = {};
+    }
+  }
+  const merged = deepMergePreservingHooks(existing, patch, dedupSubstring, force);
+  const content = `${JSON.stringify(merged, null, 2)}
+`;
+  if (existsSync2(absPath)) {
+    try {
+      if (readFileSync2(absPath, "utf8") === content) {
+        return { path: absPath, mode: "mergeJson", written: false };
+      }
+    } catch {
+    }
+  }
+  regenerate(absPath, content);
+  return { path: absPath, mode: "mergeJson", written: true };
+}
+function entryHasCommand(entry, marker) {
+  if (typeof entry !== "object" || entry === null) return false;
+  const obj = entry;
+  if (typeof obj.command === "string" && obj.command.includes(marker)) return true;
+  if (!Array.isArray(obj.hooks)) return false;
+  return obj.hooks.some((h) => {
+    if (typeof h !== "object" || h === null) return false;
+    const command = h.command;
+    return typeof command === "string" && command.includes(marker);
+  });
+}
+function deepMergePreservingHooks(existing, patch, dedupSubstring, force) {
+  const out = { ...existing };
+  for (const [key, value] of Object.entries(patch)) {
+    if (key === "hooks" && typeof value === "object" && value !== null) {
+      const existingHooks = out.hooks ?? {};
+      const mergedHooks = { ...existingHooks };
+      for (const [event, entries] of Object.entries(value)) {
+        const existingEntries = Array.isArray(mergedHooks[event]) ? mergedHooks[event] : [];
+        const patchEntries = Array.isArray(entries) ? entries : [];
+        const hasMarker = (x) => dedupSubstring !== void 0 && entryHasCommand(x, dedupSubstring);
+        const keptEntries = force === true ? existingEntries.filter((x) => !hasMarker(x)) : existingEntries;
+        const alreadyRegistered = force !== true && existingEntries.some(hasMarker);
+        const toAdd = alreadyRegistered ? [] : patchEntries;
+        mergedHooks[event] = [...keptEntries, ...toAdd];
+      }
+      out.hooks = mergedHooks;
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+// src/hooks.ts
+function emitHooksToFile(root, host, opts) {
+  const adapter = resolveAdapter(host);
+  const emissions = adapter.emitHooks?.({ command: resolveNoirCommand() }) ?? null;
+  if (emissions === null) return { host, outcomes: [] };
+  const outcomes = emissions.map((e) => {
+    const abs = join3(root, e.path);
+    mkdirSync2(dirname3(abs), { recursive: true });
+    if (e.mode === "regenerate") {
+      const content = `${JSON.stringify(e.content, null, 2)}
+`;
+      if (existsSync3(abs) && readFileSync3(abs, "utf8") === content) {
+        return { path: e.path, mode: "regenerate", written: false };
+      }
+      const out2 = regenerate(abs, content);
+      return { path: e.path, mode: "regenerate", written: out2.written };
+    }
+    const out = mergeJson(abs, e.content, e.dedupSubstring, opts?.force === true);
+    return { path: e.path, mode: "mergeJson", written: out.written };
+  });
+  return { host, outcomes };
+}
+
 // src/manifest.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join3, relative } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join5, relative } from "path";
 import {
   AGENTS_MD_FILENAME,
   emitAgentsMd,
   mcpConfigPathForAdapter,
-  resolveAdapter
+  resolveAdapter as resolveAdapter2
 } from "@noir-ai/adapters";
 import {
   CONTEXT_BLOCK,
   IGNORE_BLOCK,
-  managedBlock,
+  managedBlock as managedBlock2,
   NOIR_DIR,
   paths,
   RULES_BLOCK,
@@ -61,26 +257,26 @@ function render(template, vars) {
 }
 
 // src/template-loader.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join as join2, resolve } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname4, join as join4, resolve } from "path";
 import { fileURLToPath } from "url";
 var DEFAULT_TEMPLATES_DIR = resolveTemplatesDir();
 function resolveTemplatesDir() {
   const override = process.env.NOIR_TEMPLATES_DIR;
   if (override && override.length > 0) return resolve(override);
-  const here = dirname2(fileURLToPath(import.meta.url));
-  return join2(here, "..", "templates");
+  const here = dirname4(fileURLToPath(import.meta.url));
+  return join4(here, "..", "templates");
 }
 function loadTemplate(name) {
-  return readFileSync2(join2(DEFAULT_TEMPLATES_DIR, name), "utf8");
+  return readFileSync4(join4(DEFAULT_TEMPLATES_DIR, name), "utf8");
 }
 function templatesDir() {
   return DEFAULT_TEMPLATES_DIR;
 }
 
 // src/manifest.ts
-var BRIEF_BLOCK = managedBlock("brief", "html");
-var README_BLOCK = managedBlock("readme", "html");
+var BRIEF_BLOCK = managedBlock2("brief", "html");
+var README_BLOCK = managedBlock2("readme", "html");
 var RULES_MAP_ROW_PREFIX = "| `rules/RULES.md` |";
 function readmeMapContent(ctx) {
   const rendered = render(loadTemplate("noir-readme.md.tmpl"), ctx);
@@ -107,7 +303,7 @@ var REFRESHABLE_SEED_KIND = {
   [P.rulesMd]: "rulesSeed"
 };
 function buildManifest(ctx) {
-  return [...hostAgnosticEntries(ctx), ...buildHostArtifacts(resolveAdapter(ctx.host), ctx)];
+  return [...hostAgnosticEntries(ctx), ...buildHostArtifacts(resolveAdapter2(ctx.host), ctx)];
 }
 function hostAgnosticEntries(ctx) {
   const entries = [
@@ -212,7 +408,7 @@ function hostAgnosticEntries(ctx) {
   ];
   const isEmpty = (ctx.stack?.languages?.length ?? 0) === 0 && !ctx.stack?.packageManager;
   const isJs = isEmpty || (ctx.stack?.languages?.some((l) => l === "typescript" || l === "javascript") ?? false) || ["npm", "pnpm", "yarn"].includes(ctx.stack?.packageManager ?? "");
-  const hasDocker = isEmpty || existsSync2(join3(ctx.root, "Dockerfile")) || existsSync2(join3(ctx.root, "docker-compose.yml")) || existsSync2(join3(ctx.root, "compose.yaml"));
+  const hasDocker = isEmpty || existsSync4(join5(ctx.root, "Dockerfile")) || existsSync4(join5(ctx.root, "docker-compose.yml")) || existsSync4(join5(ctx.root, "compose.yaml"));
   const rulesEnabled = ctx.rulesEnabled !== false;
   return entries.filter((e) => {
     if (e.path === P.rulesMd) return rulesEnabled;
@@ -229,7 +425,7 @@ function buildHostArtifacts(adapter, ctx) {
   const emitsAgentsMd = host === "agents-md" || host === "cursor" || host === "opencode";
   if (emitsAgentsMd) {
     entries.push({
-      path: hostRel(adapter.agentsMdPath?.(ectx) ?? join3(ctx.root, AGENTS_MD_FILENAME), ctx.root),
+      path: hostRel(adapter.agentsMdPath?.(ectx) ?? join5(ctx.root, AGENTS_MD_FILENAME), ctx.root),
       mode: "regenerate",
       host,
       content: emitAgentsMd(ectx),
@@ -505,15 +701,15 @@ function mergeThreeWay(base, ours, theirs, style = "minimal") {
 }
 
 // src/migrations/index.ts
-import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4, rmdirSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5, relative as relative2, sep } from "path";
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync5, rmdirSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join6, relative as relative2, sep } from "path";
 import { mcpConfigPathFor, noirStdioArgs, TRANSPORT_KEYS } from "@noir-ai/adapters";
 import {
   atomicWriteFile as atomicWriteFile2,
   loadProjectInfo,
   readProjectConfig,
   readWorkspaceMarker as readWorkspaceMarker2,
-  resolveNoirCommand
+  resolveNoirCommand as resolveNoirCommand2
 } from "@noir-ai/core";
 
 // src/template-history.ts
@@ -755,171 +951,6 @@ function isStaleSeed(seed, fileBytes, currentRender) {
   return SEED_TEMPLATE_HISTORY.some((entry) => entry[seed] === fileBytes);
 }
 
-// src/writers.ts
-import {
-  closeSync,
-  existsSync as existsSync3,
-  openSync,
-  readFileSync as readFileSync3,
-  renameSync,
-  rmSync,
-  writeSync
-} from "fs";
-import { basename, dirname as dirname3, join as join4 } from "path";
-import { atomicWriteFile, stripManagedBlock, writeManagedRegion } from "@noir-ai/core";
-import { ensureOwnerOnly } from "@noir-ai/core";
-function regenerate(absPath, content) {
-  const dir = dirname3(absPath);
-  const tmp = join4(
-    dir,
-    `.${basename(absPath)}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`
-  );
-  let fd;
-  try {
-    fd = openSync(tmp, "w");
-    writeSync(fd, content, 0, "utf8");
-    closeSync(fd);
-    fd = void 0;
-    renameSync(tmp, absPath);
-  } finally {
-    if (fd !== void 0) {
-      try {
-        closeSync(fd);
-      } catch {
-      }
-    }
-    try {
-      rmSync(tmp, { force: true });
-    } catch {
-    }
-  }
-  return { path: absPath, mode: "regenerate", written: true };
-}
-function managedBlock2(absPath, block, regionText) {
-  writeManagedRegion(absPath, block, regionText);
-  return { path: absPath, mode: "managedBlock", written: true };
-}
-function managedBlocks(absPath, regions) {
-  if (regions.length === 0) {
-    throw new Error("managedBlocks requires at least one region");
-  }
-  if (regions.length === 1) {
-    const only = regions[0];
-    if (!only) throw new Error("managedBlocks: undefined region");
-    return managedBlock2(absPath, only.block, only.regionText);
-  }
-  let content = "";
-  try {
-    content = readFileSync3(absPath, "utf8");
-  } catch {
-  }
-  let stripped = content;
-  for (const r of regions) {
-    stripped = stripManagedBlock(stripped, r.block);
-  }
-  const regionsJoined = regions.map((r) => r.regionText).join("\n");
-  const next = stripped.trim().length > 0 ? `${stripped.trimEnd()}
-
-${regionsJoined}` : regionsJoined;
-  atomicWriteFile(absPath, next);
-  return { path: absPath, mode: "managedBlock", written: true };
-}
-function buildRegion(block, body) {
-  return `${block.begin}
-${body.trimEnd()}
-${block.end}
-`;
-}
-function predictManagedBlock(currentContent, block, regionText) {
-  const stripped = stripManagedBlock(currentContent, block);
-  return stripped ? `${stripped.trimEnd()}
-
-${regionText}` : regionText;
-}
-function predictManagedBlocks(currentContent, regions) {
-  if (regions.length === 0) {
-    throw new Error("predictManagedBlocks requires at least one region");
-  }
-  if (regions.length === 1) {
-    const only = regions[0];
-    if (!only) throw new Error("predictManagedBlocks: undefined region");
-    return predictManagedBlock(currentContent, only.block, only.regionText);
-  }
-  let stripped = currentContent;
-  for (const r of regions) {
-    stripped = stripManagedBlock(stripped, r.block);
-  }
-  const regionsJoined = regions.map((r) => r.regionText).join("\n");
-  return stripped.trim().length > 0 ? `${stripped.trimEnd()}
-
-${regionsJoined}` : regionsJoined;
-}
-function skipIfExists(absPath, content, fileMode) {
-  if (existsSync3(absPath)) {
-    return { path: absPath, mode: "skipIfExists", written: false };
-  }
-  atomicWriteFile(absPath, content, fileMode !== void 0 ? { mode: fileMode } : {});
-  return { path: absPath, mode: "skipIfExists", written: true };
-}
-function refreshSeed(absPath, content) {
-  atomicWriteFile(absPath, content);
-  return { path: absPath, mode: "skipIfExists", written: true };
-}
-function mergeJson(absPath, patch, dedupSubstring) {
-  let existing = {};
-  if (existsSync3(absPath)) {
-    try {
-      existing = JSON.parse(readFileSync3(absPath, "utf8"));
-    } catch {
-      existing = {};
-    }
-  }
-  const merged = deepMergePreservingHooks(existing, patch, dedupSubstring);
-  const content = `${JSON.stringify(merged, null, 2)}
-`;
-  if (existsSync3(absPath)) {
-    try {
-      if (readFileSync3(absPath, "utf8") === content) {
-        return { path: absPath, mode: "mergeJson", written: false };
-      }
-    } catch {
-    }
-  }
-  regenerate(absPath, content);
-  return { path: absPath, mode: "mergeJson", written: true };
-}
-function entryHasCommand(entry, marker) {
-  if (typeof entry !== "object" || entry === null) return false;
-  const obj = entry;
-  if (typeof obj.command === "string" && obj.command.includes(marker)) return true;
-  if (!Array.isArray(obj.hooks)) return false;
-  return obj.hooks.some((h) => {
-    if (typeof h !== "object" || h === null) return false;
-    const command = h.command;
-    return typeof command === "string" && command.includes(marker);
-  });
-}
-function deepMergePreservingHooks(existing, patch, dedupSubstring) {
-  const out = { ...existing };
-  for (const [key, value] of Object.entries(patch)) {
-    if (key === "hooks" && typeof value === "object" && value !== null) {
-      const existingHooks = out.hooks ?? {};
-      const mergedHooks = { ...existingHooks };
-      for (const [event, entries] of Object.entries(value)) {
-        const existingEntries = Array.isArray(mergedHooks[event]) ? mergedHooks[event] : [];
-        const patchEntries = Array.isArray(entries) ? entries : [];
-        const alreadyRegistered = dedupSubstring !== void 0 && existingEntries.some((x) => entryHasCommand(x, dedupSubstring));
-        const toAdd = alreadyRegistered ? [] : patchEntries;
-        mergedHooks[event] = [...existingEntries, ...toAdd];
-      }
-      out.hooks = mergedHooks;
-    } else {
-      out[key] = value;
-    }
-  }
-  return out;
-}
-
 // src/migrations/runner.ts
 function runMigrations(root, from, to, opts = {}) {
   const window = pickWindow(from ?? "0.0.0", to, MIGRATIONS);
@@ -972,9 +1003,9 @@ var synthetic = {
   run: (ctx) => {
     const result = { changed: [], conflicts: [], notes: [] };
     if (process.env.NOIR_TEST_FORCE_CONFLICT === "1" && !ctx.dryRun) {
-      const file = join5(ctx.root, ".noir", "scaffold-version");
-      if (existsSync4(file)) {
-        const prev = readFileSync4(file, "utf8");
+      const file = join6(ctx.root, ".noir", "scaffold-version");
+      if (existsSync5(file)) {
+        const prev = readFileSync5(file, "utf8");
         const merged = applyInlineConflict(prev, "noir-scaffold=1.0.0\n", "ours", "theirs");
         writeFileSync2(file, merged, "utf8");
         result.conflicts.push(".noir/scaffold-version");
@@ -1008,14 +1039,14 @@ var envPointer = {
   run: (ctx) => {
     const result = { changed: [], conflicts: [], notes: [] };
     const rel = ".noir/config.yml";
-    const abs = join5(ctx.root, ".noir", "config.yml");
-    if (!existsSync4(abs)) {
+    const abs = join6(ctx.root, ".noir", "config.yml");
+    if (!existsSync5(abs)) {
       result.notes.push(`${rel}: absent \u2014 the template seed carries the pointer`);
       return result;
     }
     let prev;
     try {
-      prev = readFileSync4(abs, "utf8");
+      prev = readFileSync5(abs, "utf8");
     } catch (err) {
       result.conflicts.push(rel);
       result.notes.push(`${rel}: unreadable (${errorMessage(err)}) \u2014 left untouched`);
@@ -1057,14 +1088,14 @@ var envTemplates = {
         result.notes.push(`${seed.rel}: skipped \u2014 the working-rules switch is off`);
         continue;
       }
-      const abs = join5(ctx.root, seed.rel);
-      if (!existsSync4(abs)) {
+      const abs = join6(ctx.root, seed.rel);
+      if (!existsSync5(abs)) {
         result.notes.push(`${seed.rel}: absent \u2014 nothing to refresh`);
         continue;
       }
       let prev;
       try {
-        prev = readFileSync4(abs, "utf8");
+        prev = readFileSync5(abs, "utf8");
       } catch (err) {
         result.conflicts.push(seed.rel);
         result.notes.push(`${seed.rel}: unreadable (${errorMessage(err)}) \u2014 left untouched`);
@@ -1100,7 +1131,7 @@ function mcpConfigPath(root) {
   } catch {
   }
   const abs = mcpConfigPathFor(host, root);
-  if (!existsSync4(abs)) return null;
+  if (!existsSync5(abs)) return null;
   return { rel: relative2(root, abs).split(sep).join("/"), abs };
 }
 var workspaceBridge = {
@@ -1121,7 +1152,7 @@ var workspaceBridge = {
     }
     let config;
     try {
-      config = JSON.parse(readFileSync4(target.abs, "utf8"));
+      config = JSON.parse(readFileSync5(target.abs, "utf8"));
     } catch (err) {
       result.conflicts.push(target.rel);
       result.notes.push(`${target.rel}: unreadable (${errorMessage(err)}) \u2014 left untouched`);
@@ -1159,7 +1190,7 @@ var workspaceBridge = {
       mcpServers: {
         ...servers,
         noir: {
-          command: resolveNoirCommand(),
+          command: resolveNoirCommand2(),
           // The argv comes from the adapters' own helper, so this rewrite lands
           // on exactly the entry a fresh join writes — the name is the whole
           // address, and the bridge resolves the daemon (and reads its token)
@@ -1190,11 +1221,11 @@ var hookCommand = {
   run: (ctx) => {
     const result = { changed: [], conflicts: [], notes: [] };
     const settingsRel = ".claude/settings.local.json";
-    const settingsPath = join5(ctx.root, ".claude", "settings.local.json");
-    if (existsSync4(settingsPath)) {
+    const settingsPath = join6(ctx.root, ".claude", "settings.local.json");
+    if (existsSync5(settingsPath)) {
       let settings;
       try {
-        settings = JSON.parse(readFileSync4(settingsPath, "utf8"));
+        settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
       } catch (err) {
         result.conflicts.push(settingsRel);
         result.notes.push(
@@ -1215,7 +1246,7 @@ var hookCommand = {
               if (typeof entry !== "object" || entry === null) continue;
               const hookObj = entry;
               if (typeof hookObj.command === "string" && hookObj.command.includes(OLD_HOOK_MARKER)) {
-                hookObj.command = `"${resolveNoirCommand()}" hook`;
+                hookObj.command = `"${resolveNoirCommand2()}" hook`;
                 rewritten = true;
               }
             }
@@ -1242,8 +1273,8 @@ var hookCommand = {
       result.notes.push(`${settingsRel}: absent \u2014 nothing to migrate`);
     }
     const runnerRel = ".noir/hooks/noir-session-start.mjs";
-    const runnerPath = join5(ctx.root, ".noir", "hooks", "noir-session-start.mjs");
-    if (!existsSync4(runnerPath)) {
+    const runnerPath = join6(ctx.root, ".noir", "hooks", "noir-session-start.mjs");
+    if (!existsSync5(runnerPath)) {
       return result;
     }
     if (ctx.dryRun) {
@@ -1260,7 +1291,7 @@ var hookCommand = {
     }
     result.changed.push(runnerRel);
     result.notes.push(`${runnerRel}: removed (orphaned runner)`);
-    const hooksDir = join5(ctx.root, ".noir", "hooks");
+    const hooksDir = join6(ctx.root, ".noir", "hooks");
     try {
       if (readdirSync(hooksDir).length === 0) rmdirSync(hooksDir);
     } catch {
@@ -1270,14 +1301,14 @@ var hookCommand = {
 };
 function applyHookEvents(ctx, rel, abs, events, createIfMissing) {
   let settings;
-  if (!existsSync4(abs)) {
+  if (!existsSync5(abs)) {
     if (!createIfMissing) {
       return { note: `${rel}: absent \u2014 nothing to migrate`, changed: false, conflict: false };
     }
     settings = {};
   } else {
     try {
-      settings = JSON.parse(readFileSync4(abs, "utf8"));
+      settings = JSON.parse(readFileSync5(abs, "utf8"));
     } catch (err) {
       return {
         note: `${rel}: unreadable (${errorMessage(err)}) \u2014 left untouched`,
@@ -1337,8 +1368,8 @@ var hookEvents = {
       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 abs = join6(ctx.root, ...rel.split("/"));
+    const command = host === "gemini" ? `"${resolveNoirCommand2()}" hook --host gemini` : `"${resolveNoirCommand2()}" hook`;
     const events = host === "gemini" ? {
       SessionStart: [{ hooks: [{ type: "command", command }] }],
       BeforeTool: [{ matcher: ".*", hooks: [{ type: "command", command }] }]
@@ -1379,21 +1410,21 @@ function applyWithConflict(ours, theirs, path) {
 }
 
 // src/scaffold.ts
-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 { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync9, renameSync as renameSync2, rmSync as rmSync3 } from "fs";
+import { basename as basename2, dirname as dirname6, join as join10 } from "path";
 import {
   createProjectId,
   loadProjectInfo as loadProjectInfo2,
   paths as paths2,
   readManagedBlock,
   readProjectConfig as readProjectConfig2,
-  resolveNoirCommand as resolveNoirCommand2,
+  resolveNoirCommand as resolveNoirCommand3,
   sha256Hex12
 } from "@noir-ai/core";
 
 // src/baseline.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
 var COMMAND_KEYS = [
   ["build", "build"],
   ["test", "test"],
@@ -1422,11 +1453,11 @@ var ENTRY_POINTS = [
 ];
 function detectCommands(root) {
   const out = {};
-  const pjPath = join6(root, "package.json");
-  if (existsSync5(pjPath)) {
+  const pjPath = join7(root, "package.json");
+  if (existsSync6(pjPath)) {
     let pj;
     try {
-      pj = JSON.parse(readFileSync5(pjPath, "utf8"));
+      pj = JSON.parse(readFileSync6(pjPath, "utf8"));
     } catch {
       pj = void 0;
     }
@@ -1435,10 +1466,10 @@ function detectCommands(root) {
       if (typeof value === "string" && value !== "") out[name] = value;
     }
   }
-  const makefile = join6(root, "Makefile");
-  if (existsSync5(makefile)) {
+  const makefile = join7(root, "Makefile");
+  if (existsSync6(makefile)) {
     try {
-      const raw = readFileSync5(makefile, "utf8");
+      const raw = readFileSync6(makefile, "utf8");
       for (const name of ["build", "test", "lint"]) {
         if (!(name in out) && new RegExp(`^${name}:`, "m").test(raw)) out[name] = `make ${name}`;
       }
@@ -1448,7 +1479,7 @@ function detectCommands(root) {
   return out;
 }
 function detectEntryPoints(root) {
-  return ENTRY_POINTS.filter((p) => existsSync5(join6(root, p)));
+  return ENTRY_POINTS.filter((p) => existsSync6(join7(root, p)));
 }
 function renderBaseline(stack, commands, entryPoints) {
   const lang = stack.languages.length > 0 ? stack.languages.join(", ") : "unknown";
@@ -1468,18 +1499,18 @@ function renderBaseline(stack, commands, entryPoints) {
 }
 
 // src/scaffold-version.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname4, join as join7 } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname5, join as join8 } from "path";
 import { NOIR_DIR as NOIR_DIR2 } from "@noir-ai/core";
 var CURRENT_SCAFFOLD_VERSION = "1.5.0";
 var PREFIX = "noir-scaffold=";
 function scaffoldVersionPath(root) {
-  return join7(root, NOIR_DIR2, "scaffold-version");
+  return join8(root, NOIR_DIR2, "scaffold-version");
 }
 function readScaffoldVersion(root) {
   let raw;
   try {
-    raw = readFileSync6(scaffoldVersionPath(root), "utf8");
+    raw = readFileSync7(scaffoldVersionPath(root), "utf8");
   } catch {
     return null;
   }
@@ -1494,14 +1525,14 @@ function readScaffoldVersion(root) {
 }
 function writeScaffoldVersion(root, version) {
   const file = scaffoldVersionPath(root);
-  mkdirSync2(dirname4(file), { recursive: true });
+  mkdirSync3(dirname5(file), { recursive: true });
   regenerate(file, `${PREFIX}${version}
 `);
 }
 
 // src/stack-detect.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync7 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync8 } from "fs";
+import { join as join9 } from "path";
 var NODE_FRAMEWORKS = [
   ["next", "next"],
   ["vite", "vite"],
@@ -1528,7 +1559,7 @@ var PYTHON_FRAMEWORKS = [
 ];
 function readJson(file) {
   try {
-    return JSON.parse(readFileSync7(file, "utf8"));
+    return JSON.parse(readFileSync8(file, "utf8"));
   } catch {
     return void 0;
   }
@@ -1538,11 +1569,11 @@ function detectStack(root) {
   const frameworks = /* @__PURE__ */ new Set();
   let monorepo = false;
   let packageManager = null;
-  const pjPath = join8(root, "package.json");
-  if (existsSync6(pjPath)) {
+  const pjPath = join9(root, "package.json");
+  if (existsSync7(pjPath)) {
     const pj = readJson(pjPath);
     if (pj) {
-      const hasTs = Boolean(pj.devDependencies?.typescript) || existsSync6(join8(root, "tsconfig.json"));
+      const hasTs = Boolean(pj.devDependencies?.typescript) || existsSync7(join9(root, "tsconfig.json"));
       languages.add(hasTs ? "typescript" : "javascript");
       const deps = /* @__PURE__ */ new Set([
         ...Object.keys(pj.dependencies ?? {}),
@@ -1561,22 +1592,22 @@ function detectStack(root) {
       }
     }
   }
-  if (existsSync6(join8(root, "pnpm-workspace.yaml"))) {
+  if (existsSync7(join9(root, "pnpm-workspace.yaml"))) {
     monorepo = true;
     packageManager = packageManager ?? "pnpm";
   }
-  if (existsSync6(join8(root, "turbo.json")) || existsSync6(join8(root, "nx.json"))) {
+  if (existsSync7(join9(root, "turbo.json")) || existsSync7(join9(root, "nx.json"))) {
     monorepo = true;
   }
   if (!packageManager) {
-    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 (existsSync7(join9(root, "pnpm-lock.yaml"))) packageManager = "pnpm";
+    else if (existsSync7(join9(root, "yarn.lock"))) packageManager = "yarn";
+    else if (existsSync7(join9(root, "package-lock.json"))) packageManager = "npm";
   }
-  if (existsSync6(join8(root, "pyproject.toml")) || existsSync6(join8(root, "requirements.txt")) || existsSync6(join8(root, "Pipfile")) || existsSync6(join8(root, "setup.py"))) {
+  if (existsSync7(join9(root, "pyproject.toml")) || existsSync7(join9(root, "requirements.txt")) || existsSync7(join9(root, "Pipfile")) || existsSync7(join9(root, "setup.py"))) {
     languages.add("python");
-    if (existsSync6(join8(root, "pyproject.toml"))) {
-      const raw = safeRead(join8(root, "pyproject.toml"));
+    if (existsSync7(join9(root, "pyproject.toml"))) {
+      const raw = safeRead(join9(root, "pyproject.toml"));
       if (raw) {
         for (const [dep, id] of PYTHON_FRAMEWORKS) {
           if (pyprojectHasDep(raw, dep)) frameworks.add(id);
@@ -1584,13 +1615,13 @@ function detectStack(root) {
       }
     }
   }
-  if (existsSync6(join8(root, "go.mod"))) {
+  if (existsSync7(join9(root, "go.mod"))) {
     languages.add("go");
     packageManager = packageManager ?? "go-modules";
   }
-  if (existsSync6(join8(root, "Cargo.toml"))) {
+  if (existsSync7(join9(root, "Cargo.toml"))) {
     languages.add("rust");
-    const raw = safeRead(join8(root, "Cargo.toml"));
+    const raw = safeRead(join9(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");
@@ -1602,7 +1633,7 @@ function detectStack(root) {
   let pmSource = "unknown";
   let pmConflict = false;
   if (packageManager) {
-    if (pjPath && existsSync6(pjPath)) {
+    if (pjPath && existsSync7(pjPath)) {
       const pj = readJson(pjPath);
       if (pj?.packageManager?.split("@")[0] === packageManager) {
         pmSource = "packageManager-field";
@@ -1631,10 +1662,10 @@ function detectStack(root) {
     }
   }
   let ci = null;
-  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";
+  if (existsSync7(join9(root, ".github", "workflows"))) ci = "github";
+  else if (existsSync7(join9(root, ".gitlab-ci.yml"))) ci = "gitlab";
+  else if (existsSync7(join9(root, ".circleci", "config.yml"))) ci = "circleci";
+  else if (existsSync7(join9(root, "Jenkinsfile"))) ci = "jenkins";
   const aiFiles = [
     ["AGENTS.md", "agents-md"],
     ["CLAUDE.md", "claude"],
@@ -1644,12 +1675,12 @@ function detectStack(root) {
   ];
   const existingAiFiles = [];
   for (const [p, kind] of aiFiles) {
-    const full = join8(root, p);
-    if (existsSync6(full)) existingAiFiles.push({ path: p, kind });
+    const full = join9(root, p);
+    if (existsSync7(full)) existingAiFiles.push({ path: p, kind });
   }
-  const cursorRulesDir = join8(root, ".cursor", "rules");
+  const cursorRulesDir = join9(root, ".cursor", "rules");
   try {
-    if (existsSync6(cursorRulesDir)) {
+    if (existsSync7(cursorRulesDir)) {
       const entries = readdirSync2(cursorRulesDir);
       for (const e of entries) {
         if (e.endsWith(".md"))
@@ -1671,7 +1702,7 @@ function detectStack(root) {
 }
 function safeRead(file) {
   try {
-    return readFileSync7(file, "utf8");
+    return readFileSync8(file, "utf8");
   } catch {
     return void 0;
   }
@@ -1698,17 +1729,17 @@ function assertSafeRoot(root) {
         `Refusing to scaffold inside a .noir/ directory (${root}). Run \`noir init\` from the project root, not from inside .noir/.`
       );
     }
-    const parent = dirname5(cur);
+    const parent = dirname6(cur);
     if (parent === cur) break;
     cur = parent;
   }
 }
 function envOwnerOnly(opts) {
   if (opts.dryRun === true) return void 0;
-  return ensureOwnerOnly(join9(paths2.noirDir(opts.root), ".env"));
+  return ensureOwnerOnly(join10(paths2.noirDir(opts.root), ".env"));
 }
 function readConfiguredHost(root) {
-  if (!existsSync7(paths2.config(root))) return "claude";
+  if (!existsSync8(paths2.config(root))) return "claude";
   try {
     return loadProjectInfo2(root).config.host;
   } catch {
@@ -1726,7 +1757,7 @@ async function scaffold(opts) {
     throw new Error("transport 'streamable-http' requires opts.url");
   }
   if (opts.mode === "create" && !opts.dryRun) {
-    mkdirSync3(opts.root, { recursive: true });
+    mkdirSync4(opts.root, { recursive: true });
   }
   const idFile = readProjectIdFile(opts.root);
   const projectId = resolveProjectId(opts, idFile);
@@ -1782,7 +1813,7 @@ async function scaffold(opts) {
     migrationConflicts.push(...m.conflicts);
     migrationChanged.push(...m.changed);
   }
-  const command = resolveNoirCommand2();
+  const command = resolveNoirCommand3();
   const manifest = buildManifest({
     root: opts.root,
     projectId,
@@ -1826,7 +1857,7 @@ async function scaffold(opts) {
   };
   const groups = groupApplicableByPath(manifest, host, emitContext);
   for (const [relPath, entries] of groups) {
-    const abs = join9(opts.root, relPath);
+    const abs = join10(opts.root, relPath);
     const managed = entries.filter((e) => e.mode === "managedBlock");
     if (managed.length >= 2) {
       if (opts.dryRun) {
@@ -1849,7 +1880,7 @@ async function scaffold(opts) {
         written.push(relPath);
         continue;
       }
-      mkdirSync3(dirname5(abs), { recursive: true });
+      mkdirSync4(dirname6(abs), { recursive: true });
       const onDisk = readOptional(abs);
       let hadMergeConflict = false;
       const regions = managed.map((e) => {
@@ -1890,7 +1921,7 @@ async function scaffold(opts) {
       }
       continue;
     }
-    if (!opts.dryRun) mkdirSync3(dirname5(abs), { recursive: true });
+    if (!opts.dryRun) mkdirSync4(dirname6(abs), { recursive: true });
     for (const entry of entries) {
       if (opts.dryRun) {
         if (opts.check === true && (entry.mode === "regenerate" || entry.mode === "managedBlock")) {
@@ -1918,7 +1949,7 @@ async function scaffold(opts) {
         }
         const seedKind = refreshableSeedKind(entry, emitContext);
         if (seedKind === void 0) {
-          if (existsSync7(abs)) {
+          if (existsSync8(abs)) {
             skipped.push(entry.path);
           } else {
             written.push(entry.path);
@@ -1985,7 +2016,7 @@ async function scaffold(opts) {
         if (onDisk !== void 0 && predicted === onDisk) {
           identical.push(entry.path);
         } else {
-          managedBlock2(abs, block, regionText);
+          managedBlock(abs, block, regionText);
           written.push(entry.path);
         }
       } else if (entry.mode === "mergeJson") {
@@ -2111,7 +2142,7 @@ async function resolveManagedConflict(relPath, mode, opts) {
 function readProjectIdFile(root) {
   let raw;
   try {
-    raw = readFileSync8(paths2.projectId(root), "utf8");
+    raw = readFileSync9(paths2.projectId(root), "utf8");
   } catch {
     return { state: "absent", id: null };
   }
@@ -2151,7 +2182,7 @@ function refreshableSeedKind(entry, emitContext) {
 async function writeWithConflict(abs, relPath, proposed, opts, internals) {
   let existing;
   try {
-    existing = readFileSync8(abs, "utf8");
+    existing = readFileSync9(abs, "utf8");
   } catch {
     existing = void 0;
   }
@@ -2212,7 +2243,7 @@ function uniqueAside(abs, relPath, suffix) {
     rel: `${relPath}${s}`
   });
   let candidate = make(suffix);
-  for (let n = 1; existsSync7(candidate.abs); n++) candidate = make(`${suffix}.${n}`);
+  for (let n = 1; existsSync8(candidate.abs); n++) candidate = make(`${suffix}.${n}`);
   return candidate;
 }
 function groupApplicableByPath(manifest, host, emitContext) {
@@ -2232,7 +2263,7 @@ function isNoirMdPath(relPath) {
 function healLegacyNoirMd(absPath) {
   let content;
   try {
-    content = readFileSync8(absPath, "utf8");
+    content = readFileSync9(absPath, "utf8");
   } catch {
     return;
   }
@@ -2248,7 +2279,7 @@ function renderEntry(entry, vars) {
 }
 function readOptional(absPath) {
   try {
-    return readFileSync8(absPath, "utf8");
+    return readFileSync9(absPath, "utf8");
   } catch (err) {
     if (err instanceof Error && err.code === "ENOENT") {
       return void 0;
@@ -2270,11 +2301,12 @@ export {
   buildManifest,
   buildRegion,
   detectStack,
+  emitHooksToFile,
   ensureOwnerOnly,
   isStaleSeed,
   lineDiff,
   loadTemplate,
-  managedBlock2 as managedBlock,
+  managedBlock,
   mergeThreeWay,
   readAncestors,
   readScaffoldVersion,