@noir-ai/create 1.16.0 → 1.17.0

package/dist/index.d.ts

@@ -238,8 +238,14 @@ interface WriteOutcome {
  *
  *  Parent directories are NOT created here — the orchestrator does that once
  *  for the whole manifest so a missing dir is a single, attributable failure
- *  rather than N silent ones inside the writer. */
-declare function regenerate(absPath: string, content: string): WriteOutcome;
+ *  rather than N silent ones inside the writer.
+ *
+ *  `mode` applies to the temp file at creation and rides the rename onto the
+ *  target, so an entry executed directly (the SessionStart hook runner) lands
+ *  with its exec bit on a first write and a rewrite alike. As with core's
+ *  `atomicWriteFile`, the requested bits are an upper bound (the process umask
+ *  can narrow them) and Windows ignores them (ACL-based permissions). */
+declare function regenerate(absPath: string, content: string, mode?: number): WriteOutcome;
 /** Re-emit a managed region, delegating to core's `writeManagedRegion`.
  *  `regionText` MUST already include the begin/end markers (matches the shape
  *  `writeManagedRegion` expects and that `IGNORE_BLOCK`/`CONTEXT_BLOCK`

package/dist/index.js

@@ -328,6 +328,16 @@ function buildHostArtifacts(adapter, ctx) {
               }
             ]
           }
+        ],
+        SubagentStart: [
+          {
+            hooks: [
+              {
+                type: "command",
+                command: `"${ctx.root}/.noir/hooks/noir-session-start.mjs"`
+              }
+            ]
+          }
         ]
       }
     };
@@ -337,11 +347,12 @@ function buildHostArtifacts(adapter, ctx) {
       host,
       content: JSON.stringify(hookEntry, null, 2),
       dedupSubstring: HOOK_DEDUP,
-      description: "SessionStart hook entry (user-owned, written once)"
+      description: "SessionStart + SubagentStart hook entry (user-owned, written once)"
     });
     entries.push({
       path: ".noir/hooks/noir-session-start.mjs",
       mode: "regenerate",
+      fileMode: 493,
       host,
       content: SESSION_START_HOOK_SCRIPT,
       description: "SessionStart hook runner (Noir-owned, re-emitted)"
@@ -354,13 +365,23 @@ function buildHostArtifacts(adapter, ctx) {
       template: "router.md.tmpl",
       description: "skill router contract (co-owned managed block)"
     });
+    if (rulesEnabled) {
+      entries.push({
+        path: ".noir/rules/anti-slop.md",
+        mode: "regenerate",
+        host,
+        template: "anti-slop.md.tmpl",
+        description: "always-on anti-slop + laziness ruleset (hook-injected, not @imported)"
+      });
+    }
   }
   return entries;
 }
 var SESSION_START_HOOK_SCRIPT = `#!/usr/bin/env node
-// Noir SessionStart hook \u2014 injects the skill router contract at session start.
-// The mutable contract lives in .noir/router.md (a Noir managed block, so user
-// edits outside the markers survive noir sync). This script is a pure runner.
+// Noir SessionStart hook \u2014 injects the skill router contract + anti-slop ruleset
+// at session start. The mutable contract lives in .noir/router.md (a Noir
+// managed block, so user edits outside the markers survive noir sync) and the
+// ruleset in .noir/rules/anti-slop.md (regenerated). This script is a pure runner.
 import { readFileSync, existsSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -368,16 +389,23 @@ import { fileURLToPath } from 'node:url';
 const HERE = dirname(fileURLToPath(import.meta.url));
 const ROOT = join(HERE, '..', '..');
 const ROUTER = join(ROOT, '.noir', 'router.md');
+const RULES = join(ROOT, '.noir', 'rules', 'anti-slop.md');
+
+function readIfPresent(path) {
+  if (!existsSync(path)) return '';
+  return readFileSync(path, 'utf8').trim();
+}
 
 function main() {
-  if (!existsSync(ROUTER)) {
-    // No router contract (project not initialized / router removed) \u2014 silent.
+  const parts = [readIfPresent(ROUTER), readIfPresent(RULES)].filter((part) => part !== '');
+  if (parts.length === 0) {
+    // Neither contract present (project not initialized / both removed) \u2014 silent.
     process.stdout.write(JSON.stringify({ hookSpecificOutput: {} }));
     process.exit(0);
   }
-  const contract = readFileSync(ROUTER, 'utf8').trim();
+  const context = parts.join('\\n\\n');
   process.stdout.write(
-    JSON.stringify({ hookSpecificOutput: { additionalContext: contract } }),
+    JSON.stringify({ hookSpecificOutput: { additionalContext: context } }),
   );
 }
 
@@ -801,7 +829,7 @@ import {
 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) {
+function regenerate(absPath, content, mode) {
   const dir = dirname3(absPath);
   const tmp = join4(
     dir,
@@ -809,7 +837,7 @@ function regenerate(absPath, content) {
   );
   let fd;
   try {
-    fd = openSync(tmp, "w");
+    fd = openSync(tmp, "w", mode);
     writeSync(fd, content, 0, "utf8");
     closeSync(fd);
     fd = void 0;
@@ -1230,7 +1258,15 @@ function applyWithConflict(ours, theirs, path) {
 }
 
 // src/scaffold.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync7, renameSync as renameSync2, rmSync as rmSync2 } from "fs";
+import {
+  chmodSync,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync7,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  statSync
+} from "fs";
 import { basename as basename2, dirname as dirname5, join as join8 } from "path";
 import {
   createProjectId,
@@ -1679,7 +1715,8 @@ async function scaffold(opts) {
       if (entry.mode === "regenerate") {
         const out = await writeWithConflict(abs, entry.path, body, opts, {
           memory: conflictMemory,
-          record: recordConflict
+          record: recordConflict,
+          mode: entry.fileMode
         });
         written.push(...out.written);
         skipped.push(...out.skipped);
@@ -1894,10 +1931,14 @@ async function writeWithConflict(abs, relPath, proposed, opts, internals) {
     existing = void 0;
   }
   if (existing === void 0) {
-    regenerate(abs, proposed);
+    regenerate(abs, proposed, internals.mode);
     return { written: [relPath], skipped: [], identical: [] };
   }
   if (existing === proposed) {
+    if (internals.mode !== void 0 && (statSync(abs).mode & 511) !== internals.mode) {
+      chmodSync(abs, internals.mode);
+      return { written: [relPath], skipped: [], identical: [] };
+    }
     return { written: [], skipped: [], identical: [relPath] };
   }
   const MODE = internals.artifactClass ?? "regenerate";
@@ -1919,21 +1960,21 @@ async function writeWithConflict(abs, relPath, proposed, opts, internals) {
   internals.record(relPath, MODE, existing, proposed, resolution, sim);
   switch (resolution) {
     case "replace":
-      regenerate(abs, proposed);
+      regenerate(abs, proposed, internals.mode);
       return { written: [relPath], skipped: [], identical: [] };
     case "merge": {
-      regenerate(abs, proposed);
+      regenerate(abs, proposed, internals.mode);
       return { written: [relPath], skipped: [], identical: [] };
     }
     case "rename": {
       const aside = uniqueAside(abs, relPath, ".local");
       renameSync2(abs, aside.abs);
-      regenerate(abs, proposed);
+      regenerate(abs, proposed, internals.mode);
       return { written: [relPath], skipped: [aside.rel], identical: [] };
     }
     case "duplicate": {
       const aside = uniqueAside(abs, relPath, ".noir");
-      regenerate(aside.abs, proposed);
+      regenerate(aside.abs, proposed, internals.mode);
       return { written: [aside.rel], skipped: [relPath], identical: [] };
     }
     case "preserve":