@nurix/etna 0.18.19 → 0.18.20

package/data/harnesses/code/skills/design/scripts/self-integrity.mjs

@@ -0,0 +1,432 @@
+// skills/design/scripts/self-integrity.mjs — the design skill's own CI check: anchor parity, catalog invariants, stated-count and fixture-pair validation
+import { readFileSync, existsSync, readdirSync } from "node:fs";
+import { join, dirname, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const SCRIPTS_DIR = dirname(fileURLToPath(import.meta.url));
+const SKILL_ROOT = join(SCRIPTS_DIR, "..");
+
+const CATALOG_CSV = join(SKILL_ROOT, "data/catalog/rules.csv");
+const FIXTURES_DIR = join(SKILL_ROOT, "data/catalog/fixtures");
+const HARD_RULES_MD = join(SKILL_ROOT, "references/hard-rules.md");
+const DETECTOR_MJS = join(SCRIPTS_DIR, "detector.mjs");
+
+const CSV_HEADER = ["id", "dimension", "statement", "numbers", "grade", "fire_points", "detector", "scope_note", "provenance", "fixture_pair"];
+const VALID_DIMENSIONS = new Set(["P1", "P2", "P3", "P4", "P5", "P6", "P7", "S1", "S2", "S3", "S4", "B1", "B2", "B3", "B4", "B5"]);
+const ANCHOR_PREFIXES = "typ|col|spc|dep|int|mot|sta|cod|proc|inst|trust";
+const ANCHOR_TOKEN = new RegExp("`(" + ANCHOR_PREFIXES + ")-(\\d{2})`", "g");
+const ANCHOR_ID = "(?:" + ANCHOR_PREFIXES + ")-\\d{2}";
+
+const PINNED = { rows: 131, source: 66, render: 10, archetypes: 6, primitives: 26, colorTokens: 34, semanticTokens: 17, substrateTokens: 17 };
+
+// Read a UTF-8 file, returning null when it does not exist.
+function readSafe(path) {
+    return existsSync(path) ? readFileSync(path, "utf8") : null;
+}
+
+// Parse RFC4180-style CSV text into an array of field arrays (quotes + doubled-quote escapes honored).
+function parseCsv(text) {
+    const rows = [];
+    let field = "";
+    let record = [];
+    let inQuotes = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inQuotes) {
+            if (ch === '"') {
+                if (text[i + 1] === '"') { field += '"'; i++; }
+                else inQuotes = false;
+            } else field += ch;
+        } else if (ch === '"') inQuotes = true;
+        else if (ch === ",") { record.push(field); field = ""; }
+        else if (ch === "\n") { record.push(field); rows.push(record); record = []; field = ""; }
+        else if (ch === "\r") { /* skip */ }
+        else field += ch;
+    }
+    if (field.length > 0 || record.length > 0) { record.push(field); rows.push(record); }
+    return rows;
+}
+
+// Split a rule id into its {prefix, num} parts, or null when it is not a well-formed anchor id.
+function splitId(id) {
+    const m = /^([a-z]+)-(\d{2})$/.exec(id);
+    return m ? { prefix: m[1], num: parseInt(m[2], 10) } : null;
+}
+
+// Strip leading whitespace and a single markdown list marker from a line.
+function stripListMarker(line) {
+    return line.replace(/^\s*/, "").replace(/^[-*+]\s+/, "");
+}
+
+// Load and index the rule catalog into typed row objects plus derived counts.
+function loadCatalog() {
+    const text = readSafe(CATALOG_CSV);
+    if (text === null) throw new Error("rules.csv not found at " + CATALOG_CSV);
+    const raw = parseCsv(text).filter((r) => r.length > 1 || (r.length === 1 && r[0].trim() !== ""));
+    const header = raw[0];
+    const dataRows = raw.slice(1).map((cells) => {
+        const obj = {};
+        CSV_HEADER.forEach((k, idx) => { obj[k] = cells[idx] !== undefined ? cells[idx] : ""; });
+        obj._cells = cells;
+        return obj;
+    });
+    return { header, rows: dataRows };
+}
+
+// ── Check 1: rules.csv is well-formed ──────────────────────────────────────────
+function checkCsvWellFormed(catalog) {
+    const errors = [];
+    const { header, rows } = catalog;
+
+    if (header.length !== CSV_HEADER.length || CSV_HEADER.some((h, i) => header[i] !== h))
+        errors.push(`header mismatch: expected [${CSV_HEADER.join(",")}] got [${header.join(",")}]`);
+
+    const seen = new Map();
+    const byPrefix = new Map();
+    for (const row of rows) {
+        if (row._cells.length !== CSV_HEADER.length)
+            errors.push(`${row.id || "?"}: has ${row._cells.length} columns, expected ${CSV_HEADER.length}`);
+
+        const parts = splitId(row.id);
+        if (!parts) { errors.push(`malformed id "${row.id}" (want <prefix>-NN)`); }
+        else {
+            if (seen.has(row.id)) errors.push(`duplicate id ${row.id}`);
+            seen.set(row.id, true);
+            if (!byPrefix.has(parts.prefix)) byPrefix.set(parts.prefix, []);
+            byPrefix.get(parts.prefix).push(parts.num);
+        }
+
+        if (!VALID_DIMENSIONS.has(row.dimension))
+            errors.push(`${row.id}: invalid dimension "${row.dimension}"`);
+
+        // grade/detector/fixture_pair invariants
+        if (row.detector === "source" && row.fixture_pair !== "yes")
+            errors.push(`${row.id}: detector=source must have fixture_pair=yes (got "${row.fixture_pair}")`);
+        if (row.grade === "judged" && !(row.detector === "none" || row.detector === "render"))
+            errors.push(`${row.id}: grade=judged must have detector none|render (got "${row.detector}")`);
+        if (row.grade === "procedure" && row.detector !== "procedure")
+            errors.push(`${row.id}: grade=procedure must have detector=procedure (got "${row.detector}")`);
+        if (!["machine", "judged", "procedure"].includes(row.grade))
+            errors.push(`${row.id}: invalid grade "${row.grade}"`);
+        if (!["source", "render", "procedure", "none"].includes(row.detector))
+            errors.push(`${row.id}: invalid detector "${row.detector}"`);
+        if (!["yes", "na"].includes(row.fixture_pair))
+            errors.push(`${row.id}: invalid fixture_pair "${row.fixture_pair}"`);
+    }
+
+    // Contiguous numbering per prefix: 1..N with no gaps, no duplicates.
+    for (const [prefix, nums] of byPrefix) {
+        const sorted = [...nums].sort((a, b) => a - b);
+        for (let i = 0; i < sorted.length; i++) {
+            if (sorted[i] !== i + 1) {
+                errors.push(`${prefix}-* numbering not contiguous: expected ${i + 1} at position ${i}, got ${sorted[i]} (full: ${sorted.join(",")})`);
+                break;
+            }
+        }
+    }
+
+    return { name: "rules.csv well-formed", pass: errors.length === 0, detail: errors.length ? `${errors.length} issue(s)` : `${rows.length} rows, ${byPrefix.size} prefixes`, errors };
+}
+
+// ── Check 2: anchor parity between rules.csv and hard-rules.md ──────────────────
+function checkAnchorParity(catalog) {
+    const errors = [];
+    const md = readSafe(HARD_RULES_MD);
+    if (md === null) return { name: "anchor parity (prose<->catalog)", pass: false, detail: "hard-rules.md missing", errors: ["hard-rules.md not found at " + HARD_RULES_MD] };
+
+    const lines = md.split("\n");
+    const defCounts = new Map(); // id -> { main, judged }
+    const rangeCovered = new Set();
+    const allBacktickIds = new Set();
+    const judgedHeader = /^##\s+judged dimensions/i;
+    let inJudged = false;
+
+    const bump = (id, section) => {
+        if (!defCounts.has(id)) defCounts.set(id, { main: 0, judged: 0 });
+        defCounts.get(id)[section]++;
+    };
+
+    for (const line of lines) {
+        if (judgedHeader.test(line.trim())) inJudged = true;
+
+        let m;
+        ANCHOR_TOKEN.lastIndex = 0;
+        while ((m = ANCHOR_TOKEN.exec(line)) !== null) allBacktickIds.add(`${m[1]}-${m[2]}`);
+
+        const body = stripListMarker(line);
+        const rangeMatch = new RegExp("^`(" + ANCHOR_ID + ")`\\s*[\\u2013\\u2014-]\\s*`(" + ANCHOR_ID + ")`").exec(body);
+        const defMatch = new RegExp("^`(" + ANCHOR_ID + ")`").exec(body);
+
+        if (rangeMatch) {
+            const a = splitId(rangeMatch[1]);
+            const b = splitId(rangeMatch[2]);
+            if (a && b && a.prefix === b.prefix) for (let n = a.num; n <= b.num; n++) rangeCovered.add(`${a.prefix}-${String(n).padStart(2, "0")}`);
+        }
+        if (defMatch) bump(defMatch[1], inJudged ? "judged" : "main");
+    }
+
+    const csvIds = new Set(catalog.rows.map((r) => r.id));
+    const proseCovered = new Set([...rangeCovered, ...defCounts.keys()]);
+
+    // No prose anchor without a csv row.
+    for (const id of allBacktickIds)
+        if (!csvIds.has(id)) errors.push(`prose anchor ${id} has no rules.csv row`);
+
+    for (const row of catalog.rows) {
+        const c = defCounts.get(row.id) || { main: 0, judged: 0 };
+        const total = c.main + c.judged;
+        const isInstTrust = row.id.startsWith("inst-") || row.id.startsWith("trust-");
+
+        if (row.grade === "machine" || row.grade === "procedure") {
+            if (c.main === 1 && c.judged === 0) { /* ok */ }
+            else if (total === 0) errors.push(`${row.grade} rule ${row.id} has no backticked definition line in hard-rules.md`);
+            else if (total > 1) errors.push(`${row.id} defined ${total} times (want exactly 1)`);
+            else if (c.judged > 0) errors.push(`${row.grade} rule ${row.id} is defined inside the Judged dimensions section`);
+        } else if (row.grade === "judged" && isInstTrust) {
+            if (!rangeCovered.has(row.id) && total === 0)
+                errors.push(`judged range rule ${row.id} not covered by a range pointer line`);
+        } else if (row.grade === "judged") {
+            if (c.judged === 1 && c.main === 0) { /* ok */ }
+            else if (total === 0) errors.push(`judged rule ${row.id} missing from the Judged dimensions index`);
+            else if (c.main > 0) errors.push(`judged rule ${row.id} defined outside the Judged dimensions section`);
+            else if (c.judged > 1) errors.push(`judged rule ${row.id} indexed ${c.judged} times (want exactly 1)`);
+        }
+
+        if (!proseCovered.has(row.id)) errors.push(`rules.csv row ${row.id} has no prose coverage`);
+    }
+
+    // The two collapsed range pointers must be present and complete.
+    for (let n = 1; n <= 11; n++) if (!rangeCovered.has(`inst-${String(n).padStart(2, "0")}`)) errors.push(`inst-${String(n).padStart(2, "0")} not covered by the inst range pointer`);
+    for (let n = 1; n <= 4; n++) if (!rangeCovered.has(`trust-0${n}`)) errors.push(`trust-0${n} not covered by the trust range pointer`);
+
+    const defTotal = [...defCounts.keys()].length;
+    return { name: "anchor parity (prose<->catalog)", pass: errors.length === 0, detail: errors.length ? `${errors.length} parity break(s)` : `${defTotal} definitions, ${rangeCovered.size} range-covered, all ${catalog.rows.length} rows covered`, errors };
+}
+
+// ── Check 3: every fixture_pair=yes rule ships a flag + pass fixture ────────────
+function checkFixturePresence(catalog) {
+    const errors = [];
+    const files = existsSync(FIXTURES_DIR) ? readdirSync(FIXTURES_DIR) : null;
+    if (files === null) {
+        const needed = catalog.rows.filter((r) => r.fixture_pair === "yes");
+        return { name: "fixture-pair presence", pass: false, detail: `fixtures dir missing; ${needed.length} pairs needed`, errors: ["data/catalog/fixtures/ does not exist"] };
+    }
+    const present = new Set(files);
+    const hasKind = (id, kind) => [...present].some((f) => f.startsWith(`${id}.${kind}.`));
+    let ok = 0;
+    for (const row of catalog.rows) {
+        if (row.fixture_pair !== "yes") continue;
+        const hasFlag = hasKind(row.id, "flag");
+        const hasPass = hasKind(row.id, "pass");
+        if (!hasFlag) errors.push(`${row.id}: missing ${row.id}.flag.*`);
+        if (!hasPass) errors.push(`${row.id}: missing ${row.id}.pass.*`);
+        if (hasFlag && hasPass) ok++;
+    }
+    const total = catalog.rows.filter((r) => r.fixture_pair === "yes").length;
+    return { name: "fixture-pair presence", pass: errors.length === 0, detail: `${ok}/${total} pairs present`, errors };
+}
+
+// Run detector.mjs on one fixture file and return the set of anchor ids it reports.
+function runDetector(file) {
+    // Scan the leading comment block for a `// detector-args:` directive (the mandatory file-path
+    // comment occupies line 1, so the directive cannot be line 0). Relative paths in it (e.g. a
+    // --manifest sibling) resolve against FIXTURES_DIR, matching each fixture's documented verify command.
+    let extra = [];
+    for (const line of (readSafe(file) || "").split("\n")) {
+        const t = line.trim();
+        if (t !== "" && !t.startsWith("//")) break;
+        const argMatch = /^\/\/\s*detector-args:\s*(.+)$/.exec(t);
+        if (argMatch) { extra = argMatch[1].trim().split(/\s+/); break; }
+    }
+    const res = spawnSync("node", [DETECTOR_MJS, file, "--json", ...extra], { encoding: "utf8", timeout: 30000, cwd: FIXTURES_DIR });
+    const out = `${res.stdout || ""}\n${res.stderr || ""}`;
+    const ids = new Set();
+    try {
+        const parsed = JSON.parse(res.stdout || "null");
+        const collect = (v) => {
+            if (v == null) return;
+            if (typeof v === "string") { const mm = /^(?:typ|col|spc|dep|int|mot|sta|cod|proc|inst|trust)-\d{2}$/.exec(v); if (mm) ids.add(v); return; }
+            if (Array.isArray(v)) { v.forEach(collect); return; }
+            if (typeof v === "object") Object.values(v).forEach(collect);
+        };
+        collect(parsed);
+    } catch { /* fall back to scanning raw output below */ }
+    let m;
+    ANCHOR_TOKEN.lastIndex = 0;
+    const bare = new RegExp("\\b(" + ANCHOR_PREFIXES + ")-(\\d{2})\\b", "g");
+    while ((m = bare.exec(out)) !== null) ids.add(`${m[1]}-${m[2]}`);
+    return { ids, spawnError: res.error ? String(res.error) : null };
+}
+
+// ── Check 4: contrastive validity — flag fires the rule, pass does not ──────────
+function checkContrastiveValidity(catalog) {
+    const errors = [];
+    if (!existsSync(DETECTOR_MJS)) return { name: "contrastive fixture validity", pass: false, detail: "detector.mjs missing", errors: ["scripts/detector.mjs not found — cannot exercise fixtures"] };
+    if (!existsSync(FIXTURES_DIR)) return { name: "contrastive fixture validity", pass: false, detail: "fixtures dir missing", errors: ["data/catalog/fixtures/ does not exist"] };
+    const files = readdirSync(FIXTURES_DIR);
+    const present = new Set(files);
+    const findFile = (id, kind) => files.find((f) => f.startsWith(`${id}.${kind}.`));
+    let checked = 0;
+    for (const row of catalog.rows) {
+        if (row.fixture_pair !== "yes") continue;
+        const flag = findFile(row.id, "flag");
+        const pass = findFile(row.id, "pass");
+        if (!flag || !pass) continue; // absence is check 3's job
+        checked++;
+        const flagRes = runDetector(join(FIXTURES_DIR, flag));
+        if (flagRes.spawnError) { errors.push(`${row.id}: detector spawn failed on flag (${flagRes.spawnError})`); continue; }
+        if (!flagRes.ids.has(row.id)) errors.push(`${row.id}: flag fixture did not report ${row.id} (reported: ${[...flagRes.ids].join(",") || "none"})`);
+        const passRes = runDetector(join(FIXTURES_DIR, pass));
+        if (passRes.spawnError) { errors.push(`${row.id}: detector spawn failed on pass (${passRes.spawnError})`); continue; }
+        if (passRes.ids.has(row.id)) errors.push(`${row.id}: pass fixture wrongly reported ${row.id}`);
+    }
+    return { name: "contrastive fixture validity", pass: errors.length === 0, detail: `${checked} pair(s) exercised`, errors };
+}
+
+const NUMBER_WORDS = { one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9, ten: 10, eleven: 11, twelve: 12, thirteen: 13, fourteen: 14, fifteen: 15, sixteen: 16, seventeen: 17, eighteen: 18, nineteen: 19, twenty: 20, "twenty-six": 26 };
+
+// Resolve a numeric token (digits or an English number word) to a number, or NaN.
+function toNumber(tok) {
+    if (/^\d+$/.test(tok)) return parseInt(tok, 10);
+    return NUMBER_WORDS[tok.toLowerCase()] ?? NaN;
+}
+
+// ── Check 5: stated counts in prose match the ground truth ─────────────────────
+function checkStatedCounts(catalog, ground) {
+    const errors = [];
+    // Ground truth drift guard: derived CSV counts must match the pinned numbers.
+    if (ground.rows !== PINNED.rows) errors.push(`derived row count ${ground.rows} != pinned ${PINNED.rows}`);
+    if (ground.source !== PINNED.source) errors.push(`derived source count ${ground.source} != pinned ${PINNED.source}`);
+    if (ground.render !== PINNED.render) errors.push(`derived machine-render count ${ground.render} != pinned ${PINNED.render}`);
+
+    const gtMap = {
+        rules: ground.rows, rule: ground.rows, rows: ground.rows, row: ground.rows,
+        source: ground.source, render: ground.render,
+        archetypes: PINNED.archetypes, archetype: PINNED.archetypes,
+        primitives: PINNED.primitives, primitive: PINNED.primitives,
+        "color-tokens": PINNED.colorTokens, "color tokens": PINNED.colorTokens, colortokens: PINNED.colorTokens,
+        "semantic-tokens": PINNED.semanticTokens, "substrate-tokens": PINNED.substrateTokens,
+    };
+
+    const targets = [join(SKILL_ROOT, "SKILL.md"), ...(existsSync(join(SKILL_ROOT, "references")) ? readdirSync(join(SKILL_ROOT, "references")).filter((f) => f.endsWith(".md")).map((f) => join(SKILL_ROOT, "references", f)) : [])];
+    let commentClaims = 0;
+    let bareClaims = 0;
+    for (const file of targets) {
+        const text = readSafe(file);
+        if (text === null) continue;
+        const rel = file.replace(SKILL_ROOT + "/", "");
+        const linesArr = text.split("\n");
+        linesArr.forEach((line, i) => {
+            // (a) machine-readable HTML comment claims: <!-- count:<name>=<n> -->
+            const cmt = /<!--\s*count:([a-z0-9 _-]+)=(\d+)\s*-->/gi;
+            let cm;
+            while ((cm = cmt.exec(line)) !== null) {
+                commentClaims++;
+                const name = cm[1].trim().toLowerCase().replace(/\s+/g, "-");
+                const val = parseInt(cm[2], 10);
+                const expected = gtMap[name] ?? gtMap[name.replace(/-/g, " ")];
+                if (expected === undefined) errors.push(`${rel}:${i + 1}: count comment names unknown quantity "${cm[1].trim()}"`);
+                else if (expected !== val) errors.push(`${rel}:${i + 1}: count:${cm[1].trim()}=${val} but ground truth is ${expected}`);
+            }
+            // (b) bare claims of the exact named forms. Require adjacency (number immediately
+            // before the noun) so qualified subset phrases ("24 static primitives", "one layout
+            // primitive") are not misread as grand-total claims.
+            const bare = /\b(\d+|[a-z]+)\s+(rules?|archetypes?|primitives?)\b/gi;
+            let bm;
+            while ((bm = bare.exec(line)) !== null) {
+                const n = toNumber(bm[1]);
+                if (Number.isNaN(n)) continue;
+                const key = bm[2].toLowerCase();
+                const expected = gtMap[key];
+                if (expected === undefined) continue;
+                bareClaims++;
+                if (n !== expected) errors.push(`${rel}:${i + 1}: bare claim "${bm[0].trim()}" (=${n}) contradicts ground truth ${expected}`);
+            }
+        });
+    }
+    return { name: "stated-count integrity", pass: errors.length === 0, detail: `${commentClaims} comment + ${bareClaims} bare claim(s) checked`, errors };
+}
+
+// ── Check 6: every brief-pinned path exists ────────────────────────────────────
+function checkFileTree() {
+    const errors = [];
+    const files = [
+        "SKILL.md",
+        "references/hard-rules.md", "references/create.md", "references/improve.md", "references/introspect.md",
+        "references/diagnosis.md", "references/structure.md", "references/personality.md", "references/interaction.md", "references/lifecycle.md",
+        "data/catalog/rules.csv",
+        "data/design-md/SCHEMA.md", "data/design-md/nurix.md",
+        "data/operator-pack/surface-catalog.md", "data/operator-pack/fixtures.md", "data/operator-pack/trust-rubric.md",
+        "data/operator-pack/exemplars/list-detail.tsx", "data/operator-pack/exemplars/dashboard.tsx",
+        "data/operator-pack/exemplars/entity-detail.tsx", "data/operator-pack/exemplars/create-edit.tsx",
+        "data/operator-pack/exemplars/log-stream.tsx", "data/operator-pack/exemplars/command-center.tsx",
+        "scripts/detector.mjs", "scripts/phase-gate.mjs", "scripts/preship-sweep.mjs", "scripts/render-rung.mjs",
+        "scripts/scaffold.mjs", "scripts/derive-personality.mjs", "scripts/generate-fixtures.mjs",
+        "scripts/self-integrity.mjs", "scripts/hook-config.json",
+    ];
+    for (const rel of files) if (!existsSync(join(SKILL_ROOT, rel))) errors.push(`missing ${rel}`);
+
+    const dirs = ["data/catalog/fixtures", "data/design-md/library"];
+    for (const rel of dirs) {
+        const abs = join(SKILL_ROOT, rel);
+        if (!existsSync(abs)) errors.push(`missing dir ${rel}/`);
+        else if (readdirSync(abs).length === 0) errors.push(`empty dir ${rel}/`);
+    }
+    const found = files.length - errors.filter((e) => e.startsWith("missing ")).length;
+    return { name: "file-tree presence", pass: errors.length === 0, detail: `${found}/${files.length} files present`, errors };
+}
+
+// Derive the ground-truth counts from the catalog itself.
+function deriveGround(catalog) {
+    return {
+        rows: catalog.rows.length,
+        source: catalog.rows.filter((r) => r.detector === "source").length,
+        render: catalog.rows.filter((r) => r.detector === "render" && r.grade === "machine").length,
+    };
+}
+
+// Run every check, print the summary table, and exit non-zero on any failure.
+function main() {
+    const results = [];
+    let catalog = null;
+    try { catalog = loadCatalog(); } catch (e) {
+        console.error("FATAL: " + e.message);
+        process.exit(2);
+    }
+    const ground = deriveGround(catalog);
+
+    const runners = [
+        () => checkCsvWellFormed(catalog),
+        () => checkAnchorParity(catalog),
+        () => checkFixturePresence(catalog),
+        () => checkContrastiveValidity(catalog),
+        () => checkStatedCounts(catalog, ground),
+        () => checkFileTree(),
+    ];
+    for (const run of runners) {
+        try { results.push(run()); }
+        catch (e) { results.push({ name: run.name || "check", pass: false, detail: "threw", errors: [e.stack || String(e)] }); }
+    }
+
+    for (const r of results) {
+        if (r.errors && r.errors.length) {
+            console.log(`\n[${r.pass ? "PASS" : "FAIL"}] ${r.name}`);
+            for (const e of r.errors) console.log(`   - ${e}`);
+        }
+    }
+
+    console.log("\n" + "=".repeat(60));
+    console.log("self-integrity — design skill");
+    console.log("=".repeat(60));
+    const pad = (s, n) => (s + " ".repeat(n)).slice(0, n);
+    for (const r of results) console.log(`${r.pass ? "PASS" : "FAIL"}  ${pad(r.name, 34)} ${r.detail}`);
+    console.log("=".repeat(60));
+
+    const failed = results.filter((r) => !r.pass);
+    if (failed.length) { console.log(`${failed.length} check(s) failed.`); process.exit(1); }
+    console.log("all checks passed.");
+    process.exit(0);
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nurix/etna",
-    "version": "0.18.19",
+    "version": "0.18.20",
     "description": "Bootstrap a project with a Nurix harness — copies the harness's CLAUDE.md, skills, agents, rules, and hooks directly into the project from a bundled payload (no marketplace fetch, no network).",
     "type": "module",
     "bin": {