vigiles 2.0.0 → 2.1.1

package/dist/evolve.js

@@ -13,6 +13,7 @@ exports.applyMutation = applyMutation;
 exports.runProofSuite = runProofSuite;
 const proofs_js_1 = require("./proofs.js");
 const compile_js_1 = require("./compile.js");
+const hash_js_1 = require("./hash.js");
 /**
  * Shallow-clone a Rule. Rules are simple value types (primitive fields only),
  * so a spread is sufficient to decouple engine state from the caller's
@@ -119,7 +120,7 @@ function applyMutation(rules, mutation) {
                     rules,
                     error: {
                         mutation,
-                        reason: `Rule "${mutation.ruleId}" is already at maximum strength (enforce)`,
+                        reason: `Rule "${mutation.ruleId}" is already at maximum strength (${rule._kind})`,
                     },
                 };
             }
@@ -142,6 +143,12 @@ function applyMutation(rules, mutation) {
                     text: rule.why,
                 };
             }
+            else if (rule._kind === "guard") {
+                next[mutation.ruleId] = {
+                    _kind: "guidance",
+                    text: rule.description,
+                };
+            }
             else {
                 return {
                     rules,
@@ -230,8 +237,13 @@ function applyMutation(rules, mutation) {
             else if (rule._kind === "enforce") {
                 next[mutation.ruleId] = { ...rule, why: mutation.newText };
             }
+            else if (rule._kind === "guard") {
+                next[mutation.ruleId] = { ...rule, description: mutation.newText };
+            }
             return { rules: next };
         }
+        default:
+            return (0, hash_js_1.assertNever)(mutation);
     }
 }
 /**
@@ -258,107 +270,61 @@ function runProofSuite(before, after, options = {}) {
     });
     // 2. NCD deduplication. Only fail on pairs NEWLY INTRODUCED by the
     // candidate change — a repo with historical duplication must not
-    // block every unrelated mutation. Compute similar pairs on `after`
-    // and `before`, then subtract.
-    //
-    // Wrapped in try/catch so an unknown rule kind (legacy data / JS
-    // caller) surfaces as a clean proof failure rather than crashing
-    // the whole audit pipeline.
-    try {
-        const beforePairs = new Set((0, proofs_js_1.findSimilarRules)(before, ncdThreshold).map((p) => [p.idA, p.idB].sort().join("|")));
-        const similar = (0, proofs_js_1.findSimilarRules)(after, ncdThreshold).filter((p) => !beforePairs.has([p.idA, p.idB].sort().join("|")));
-        const ncdPassed = similar.length === 0;
-        receipts.push({
-            name: "ncd-dedup",
-            passed: ncdPassed,
-            detail: ncdPassed
-                ? "No new near-duplicate rules"
-                : `${similar.length} new near-duplicate pairs: ${similar.map((p) => `${p.idA}↔${p.idB} (${p.distance.toFixed(3)})`).join(", ")}`,
-        });
-    }
-    catch (e) {
-        receipts.push({
-            name: "ncd-dedup",
-            passed: false,
-            detail: `Similarity check failed: ${e instanceof Error ? e.message : String(e)}`,
-        });
-    }
+    // block every unrelated mutation.
+    const beforePairs = new Set((0, proofs_js_1.findSimilarRules)(before, ncdThreshold).map((p) => [p.idA, p.idB].sort().join("|")));
+    const similar = (0, proofs_js_1.findSimilarRules)(after, ncdThreshold).filter((p) => !beforePairs.has([p.idA, p.idB].sort().join("|")));
+    const ncdPassed = similar.length === 0;
+    receipts.push({
+        name: "ncd-dedup",
+        passed: ncdPassed,
+        detail: ncdPassed
+            ? "No new near-duplicate rules"
+            : `${similar.length} new near-duplicate pairs: ${similar.map((p) => `${p.idA}↔${p.idB} (${p.distance.toFixed(3)})`).join(", ")}`,
+    });
     // 3. Bloom filter cross-check (fast sanity check for token overlap).
     // Baseline is built from rules that still exist in `after` — any
     // rule removed by the candidate mutation (e.g. the two sources of
     // a merge) must be excluded, otherwise the newly introduced merge
     // rule would collide against its own sources and the merge would
     // be rejected for the very similarity it was meant to deduplicate.
-    //
-    // Wrapped for the same reason as NCD: ruleToBloomFilter → ruleToText
-    // throws on unknown rule kinds.
-    try {
-        let bloomPassed = true;
-        const newRuleIds = Object.keys(after).filter((id) => !(id in before));
-        const existingFilters = new Map();
-        for (const [id, rule] of Object.entries(before)) {
-            if (!(id in after))
-                continue; // removed — skip
-            existingFilters.set(id, (0, proofs_js_1.ruleToBloomFilter)(rule));
-        }
-        const bloomOverlaps = [];
-        for (const newId of newRuleIds) {
-            const newFilter = (0, proofs_js_1.ruleToBloomFilter)(after[newId]);
-            for (const [existingId, existingFilter] of existingFilters) {
-                if (existingId === newId)
-                    continue;
-                try {
-                    const similarity = proofs_js_1.BloomFilter.jaccardSimilarity(newFilter, existingFilter);
-                    if (similarity > 0.7) {
-                        bloomOverlaps.push(`${newId}↔${existingId} (jaccard=${similarity.toFixed(3)})`);
-                        bloomPassed = false;
-                    }
-                }
-                catch {
-                    // Different filter sizes — skip comparison
+    let bloomPassed = true;
+    const newRuleIds = Object.keys(after).filter((id) => !(id in before));
+    const existingFilters = new Map();
+    for (const [id, rule] of Object.entries(before)) {
+        if (!(id in after))
+            continue;
+        existingFilters.set(id, (0, proofs_js_1.ruleToBloomFilter)(rule));
+    }
+    const bloomOverlaps = [];
+    for (const newId of newRuleIds) {
+        const newFilter = (0, proofs_js_1.ruleToBloomFilter)(after[newId]);
+        for (const [existingId, existingFilter] of existingFilters) {
+            if (existingId === newId)
+                continue;
+            try {
+                const similarity = proofs_js_1.BloomFilter.jaccardSimilarity(newFilter, existingFilter);
+                if (similarity > 0.7) {
+                    bloomOverlaps.push(`${newId}↔${existingId} (jaccard=${similarity.toFixed(3)})`);
+                    bloomPassed = false;
                 }
             }
+            catch {
+                // Different filter sizes — skip comparison
+            }
         }
-        receipts.push({
-            name: "bloom-overlap",
-            passed: bloomPassed,
-            detail: bloomPassed
-                ? "No suspicious token overlap"
-                : `High overlap: ${bloomOverlaps.join(", ")}`,
-        });
-    }
-    catch (e) {
-        receipts.push({
-            name: "bloom-overlap",
-            passed: false,
-            detail: `Bloom filter check failed: ${e instanceof Error ? e.message : String(e)}`,
-        });
     }
-    // Compute fitness of the new spec. Guard against bad runtime data: fitness
-    // recomputes similarity internally and would otherwise crash on unknown
-    // rule kinds (legacy `check`, JS caller), propagating the throw up through
-    // the engine. Fall back to a neutral fitness and mark the proof failed.
+    receipts.push({
+        name: "bloom-overlap",
+        passed: bloomPassed,
+        detail: bloomPassed
+            ? "No suspicious token overlap"
+            : `High overlap: ${bloomOverlaps.join(", ")}`,
+    });
     const specForFitness = { rules: after };
-    let fitnessResult;
-    try {
-        fitnessResult = (0, proofs_js_1.fitness)(specForFitness, {
-            maxTokens: options.maxTokens,
-            ncdThreshold,
-        });
-    }
-    catch (e) {
-        receipts.push({
-            name: "fitness",
-            passed: false,
-            detail: `Fitness computation failed: ${e instanceof Error ? e.message : String(e)}`,
-        });
-        fitnessResult = {
-            score: 0,
-            coverage: 0,
-            redundancy: 0,
-            budgetPressure: 0,
-        };
-    }
+    const fitnessResult = (0, proofs_js_1.fitness)(specForFitness, {
+        maxTokens: options.maxTokens,
+        ncdThreshold,
+    });
     const allPassed = receipts.every((r) => r.passed);
     return { passed: allPassed, receipts, fitness: fitnessResult };
 }
@@ -454,40 +420,7 @@ class EvolutionEngine {
      * Returns a detailed result including proof receipts and fitness comparison.
      */
     propose(mutation) {
-        // Guard baseline fitness: if engine state contains a malformed rule
-        // (legacy _kind, JS caller, cast bypass), fitness() reaches ruleToText
-        // and throws BEFORE we enter runProofSuite's own try/catch. Return a
-        // clean rejection with a neutral fitness instead of crashing the flow.
-        let beforeFitness;
-        try {
-            beforeFitness = this.getFitness();
-        }
-        catch (e) {
-            const neutral = {
-                score: 0,
-                coverage: 0,
-                redundancy: 0,
-                budgetPressure: 0,
-            };
-            return {
-                accepted: false,
-                mutation,
-                proofs: {
-                    passed: false,
-                    receipts: [
-                        {
-                            name: "baseline-fitness",
-                            passed: false,
-                            detail: `Baseline fitness failed: ${e instanceof Error ? e.message : String(e)}`,
-                        },
-                    ],
-                    fitness: neutral,
-                },
-                beforeFitness: neutral,
-                afterFitness: neutral,
-                error: `Baseline fitness failed: ${e instanceof Error ? e.message : String(e)}`,
-            };
-        }
+        const beforeFitness = this.getFitness();
         // Apply the mutation
         const { rules: candidateRules, error } = applyMutation(this.rules, mutation);
         if (error) {
@@ -594,6 +527,8 @@ function describeMutation(mutation) {
             return `Merge "${mutation.sourceIds[0]}" + "${mutation.sourceIds[1]}" → "${mutation.mergedId}"`;
         case "reword":
             return `Reword rule "${mutation.ruleId}"`;
+        default:
+            return (0, hash_js_1.assertNever)(mutation);
     }
 }
 //# sourceMappingURL=evolve.js.map

package/dist/frontmatter.d.ts

@@ -0,0 +1,57 @@
+/**
+ * vigiles — YAML frontmatter rule mode (Level 1 adoption).
+ *
+ * Parses a `vigiles.enforce` block out of a markdown file's YAML
+ * frontmatter, so a project can declare enforce rules in structured YAML
+ * instead of `<!-- vigiles:enforce ... -->` HTML comments (Level 0) or a
+ * typed `.spec.ts` (Level 2). Every frontmatter rule goes through the same
+ * `checkLinterRule` verification as inline and spec rules.
+ *
+ * Shape (verbose — chosen so a JSON Schema can give `rule` an enum that
+ * YAML LSP autocompletes and squiggles on typo):
+ *
+ *   ---
+ *   # yaml-language-server: $schema=./.vigiles/schema.json
+ *   vigiles:
+ *     enforce:
+ *       - rule: "@typescript-eslint/no-explicit-any"
+ *         why: "Use unknown"
+ *   ---
+ *
+ * Like inline mode, only `enforce` is supported — the prose body of the
+ * file is the guidance. Malformed YAML is reported, never thrown: a broken
+ * frontmatter block produces an error finding, not a crash.
+ */
+export interface FrontmatterRule {
+    /** Linter rule reference, e.g. "eslint/no-console". */
+    linterRule: string;
+    /** Why this rule is enforced (human-readable, shown in agent context). */
+    why: string;
+    /** 1-based line number of the rule in the source file (best-effort). */
+    line: number;
+}
+export interface FrontmatterParseResult {
+    rules: FrontmatterRule[];
+    /** Frontmatter that looks like a vigiles block but failed to parse. */
+    errors: {
+        line: number;
+        message: string;
+    }[];
+}
+/**
+ * Parse `vigiles.enforce` rules out of a markdown file's YAML frontmatter.
+ * Does not touch the filesystem and does not verify rules against any
+ * linter — callers feed the returned rules into `checkLinterRule`.
+ *
+ * A file with no frontmatter, or frontmatter with no `vigiles` key, yields
+ * empty results with no errors. Malformed YAML or a malformed `vigiles`
+ * block yields error findings (never throws).
+ */
+export declare function parseFrontmatterRules(content: string): FrontmatterParseResult;
+/**
+ * True if the content has at least one parseable `vigiles.enforce` rule in
+ * its frontmatter. Used by `require-spec` validation to treat frontmatter
+ * mode as spec-equivalent, mirroring `hasInlineRules`.
+ */
+export declare function hasFrontmatterRules(content: string): boolean;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/frontmatter.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * vigiles — YAML frontmatter rule mode (Level 1 adoption).
+ *
+ * Parses a `vigiles.enforce` block out of a markdown file's YAML
+ * frontmatter, so a project can declare enforce rules in structured YAML
+ * instead of `<!-- vigiles:enforce ... -->` HTML comments (Level 0) or a
+ * typed `.spec.ts` (Level 2). Every frontmatter rule goes through the same
+ * `checkLinterRule` verification as inline and spec rules.
+ *
+ * Shape (verbose — chosen so a JSON Schema can give `rule` an enum that
+ * YAML LSP autocompletes and squiggles on typo):
+ *
+ *   ---
+ *   # yaml-language-server: $schema=./.vigiles/schema.json
+ *   vigiles:
+ *     enforce:
+ *       - rule: "@typescript-eslint/no-explicit-any"
+ *         why: "Use unknown"
+ *   ---
+ *
+ * Like inline mode, only `enforce` is supported — the prose body of the
+ * file is the guidance. Malformed YAML is reported, never thrown: a broken
+ * frontmatter block produces an error finding, not a crash.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFrontmatterRules = parseFrontmatterRules;
+exports.hasFrontmatterRules = hasFrontmatterRules;
+const js_yaml_1 = require("js-yaml");
+const BOM = "";
+const OPEN_RE = /^---[ \t]*\r?\n/;
+const CLOSE_RE = /\r?\n(?:---|\.\.\.)[ \t]*(?:\r?\n|$)/;
+/**
+ * Extract the YAML frontmatter block. Frontmatter must be the very first
+ * thing in the file (after an optional BOM): a `---` line, the YAML body,
+ * then a closing `---` or `...` line. Returns null when no block is present.
+ */
+function extractFrontmatter(content) {
+    const text = content.startsWith(BOM) ? content.slice(BOM.length) : content;
+    const open = OPEN_RE.exec(text);
+    if (!open)
+        return null;
+    const rest = text.slice(open[0].length);
+    const close = CLOSE_RE.exec(rest);
+    if (!close)
+        return null;
+    // Line 1 is the opening `---`; YAML content starts on line 2.
+    return { yaml: rest.slice(0, close.index), startLine: 2 };
+}
+/** First 1-based line at or after `fromIndex` whose text contains `needle`. */
+function findLine(lines, needle, fromIndex) {
+    for (let i = fromIndex; i < lines.length; i++) {
+        if (lines[i].includes(needle))
+            return i + 1;
+    }
+    return fromIndex + 1;
+}
+/**
+ * Navigate a parsed frontmatter document to its `vigiles.enforce` list.
+ * Returns "none" when there's nothing for vigiles to check, "error" when a
+ * `vigiles`/`enforce` key is present but the wrong shape, or the list.
+ */
+function lookupEnforce(doc, lines, startLine) {
+    if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+        return { kind: "none" };
+    }
+    const vigiles = doc.vigiles;
+    if (vigiles === undefined)
+        return { kind: "none" };
+    if (vigiles === null ||
+        typeof vigiles !== "object" ||
+        Array.isArray(vigiles)) {
+        return {
+            kind: "error",
+            error: {
+                line: findLine(lines, "vigiles:", startLine - 1),
+                message: "`vigiles` frontmatter key must be a mapping.",
+            },
+        };
+    }
+    const enforce = vigiles.enforce;
+    if (enforce === undefined)
+        return { kind: "none" };
+    const enforceLine = findLine(lines, "enforce:", startLine - 1);
+    if (!Array.isArray(enforce)) {
+        return {
+            kind: "error",
+            error: {
+                line: enforceLine,
+                message: "`vigiles.enforce` must be a list of { rule, why } entries.",
+            },
+        };
+    }
+    return { kind: "list", enforce, enforceLine };
+}
+/** Parse one `vigiles.enforce` entry into a rule or an error finding. */
+function parseEntry(entry, index, ctx) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+        return {
+            error: {
+                line: ctx.enforceLine,
+                message: `vigiles.enforce[${String(index)}] must be a mapping with \`rule\` and \`why\`.`,
+            },
+            nextCursor: ctx.cursor,
+        };
+    }
+    const { rule, why } = entry;
+    if (typeof rule !== "string" || rule.trim() === "") {
+        return {
+            error: {
+                line: ctx.enforceLine,
+                message: `vigiles.enforce[${String(index)}] is missing a string \`rule\`.`,
+            },
+            nextCursor: ctx.cursor,
+        };
+    }
+    const line = findLine(ctx.lines, rule, ctx.cursor);
+    if (typeof why !== "string" || why.trim() === "") {
+        return {
+            error: {
+                line,
+                message: `vigiles.enforce[${String(index)}] (rule "${rule}") is missing a string \`why\`.`,
+            },
+            nextCursor: line,
+        };
+    }
+    return { rule: { linterRule: rule, why, line }, nextCursor: line };
+}
+/**
+ * Parse `vigiles.enforce` rules out of a markdown file's YAML frontmatter.
+ * Does not touch the filesystem and does not verify rules against any
+ * linter — callers feed the returned rules into `checkLinterRule`.
+ *
+ * A file with no frontmatter, or frontmatter with no `vigiles` key, yields
+ * empty results with no errors. Malformed YAML or a malformed `vigiles`
+ * block yields error findings (never throws).
+ */
+function parseFrontmatterRules(content) {
+    const fm = extractFrontmatter(content);
+    if (!fm)
+        return { rules: [], errors: [] };
+    const lines = content.split("\n");
+    let doc;
+    try {
+        doc = (0, js_yaml_1.load)(fm.yaml);
+    }
+    catch (e) {
+        const err = e;
+        const line = (err.mark?.line ?? 0) + fm.startLine;
+        return {
+            rules: [],
+            errors: [
+                {
+                    line,
+                    message: `Malformed YAML frontmatter: ${err.reason ?? err.message}`,
+                },
+            ],
+        };
+    }
+    const lookup = lookupEnforce(doc, lines, fm.startLine);
+    if (lookup.kind === "none")
+        return { rules: [], errors: [] };
+    if (lookup.kind === "error")
+        return { rules: [], errors: [lookup.error] };
+    const rules = [];
+    const errors = [];
+    let cursor = lookup.enforceLine; // search start: line after `enforce:`
+    for (let i = 0; i < lookup.enforce.length; i++) {
+        const r = parseEntry(lookup.enforce[i], i, {
+            lines,
+            enforceLine: lookup.enforceLine,
+            cursor,
+        });
+        cursor = r.nextCursor;
+        if (r.rule)
+            rules.push(r.rule);
+        if (r.error)
+            errors.push(r.error);
+    }
+    return { rules, errors };
+}
+/**
+ * True if the content has at least one parseable `vigiles.enforce` rule in
+ * its frontmatter. Used by `require-spec` validation to treat frontmatter
+ * mode as spec-equivalent, mirroring `hasInlineRules`.
+ */
+function hasFrontmatterRules(content) {
+    return parseFrontmatterRules(content).rules.length > 0;
+}
+//# sourceMappingURL=frontmatter.js.map

package/dist/generate-schema.d.ts

@@ -0,0 +1,51 @@
+/**
+ * vigiles generate-schema — emit a JSON Schema for `vigiles:` frontmatter.
+ *
+ * Sibling of `generate-types` (which emits a `.d.ts` for the spec.ts path).
+ * This emits `.vigiles/schema.json` so a YAML LSP can autocomplete rule
+ * names and squiggle typos in markdown frontmatter:
+ *
+ *   ---
+ *   # yaml-language-server: $schema=./.vigiles/schema.json
+ *   vigiles:
+ *     enforce:
+ *       - rule: eslint/no-consolee   # red squiggle in VS Code
+ *   ---
+ *
+ * The `rule` enum is populated from the project's ACTUAL enabled linter
+ * rules — the same discovery `generate-types` runs — so the schema reflects
+ * what is really enforceable, not a static catalog.
+ */
+export interface GenerateSchemaOptions {
+    basePath?: string;
+    /**
+     * Custom linters from `.vigilesrc.json` (`rulesDir`-backed). These aren't
+     * auto-discovered by `generate-types`, but `vigiles audit` resolves their
+     * rules via `checkLinterRule`, so the schema enum must include them too —
+     * otherwise the YAML LSP false-flags a rule that CI accepts.
+     */
+    linters?: Record<string, {
+        rulesDir?: string | string[];
+    }>;
+}
+export interface GenerateSchemaResult {
+    /** The JSON Schema document. */
+    schema: Record<string, unknown>;
+    /** Pretty-printed JSON, newline-terminated. */
+    json: string;
+    /** Rule names included in the enum (sorted, deduped). */
+    ruleNames: string[];
+    /** Linters discovered, with rule counts. */
+    linters: {
+        linter: string;
+        count: number;
+    }[];
+}
+/**
+ * Build a JSON Schema for the `vigiles:` frontmatter block from the
+ * project's discovered linter rules. When no rules are discoverable the
+ * `rule` field falls back to a freeform string so the schema never
+ * false-flags a valid reference.
+ */
+export declare function generateSchema(options?: GenerateSchemaOptions): GenerateSchemaResult;
+//# sourceMappingURL=generate-schema.d.ts.map

package/dist/generate-schema.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * vigiles generate-schema — emit a JSON Schema for `vigiles:` frontmatter.
+ *
+ * Sibling of `generate-types` (which emits a `.d.ts` for the spec.ts path).
+ * This emits `.vigiles/schema.json` so a YAML LSP can autocomplete rule
+ * names and squiggle typos in markdown frontmatter:
+ *
+ *   ---
+ *   # yaml-language-server: $schema=./.vigiles/schema.json
+ *   vigiles:
+ *     enforce:
+ *       - rule: eslint/no-consolee   # red squiggle in VS Code
+ *   ---
+ *
+ * The `rule` enum is populated from the project's ACTUAL enabled linter
+ * rules — the same discovery `generate-types` runs — so the schema reflects
+ * what is really enforceable, not a static catalog.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchema = generateSchema;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const glob_1 = require("glob");
+const generate_types_js_1 = require("./generate-types.js");
+/**
+ * Rule references for config-declared custom linters. Mirrors
+ * `checkLinterRule`'s rulesDir lookup (any file `<rule>.*` is a rule) so the
+ * enum matches what `vigiles audit` accepts for these linters.
+ */
+function customRuleRefs(basePath, linters) {
+    const refs = [];
+    for (const [name, cfg] of Object.entries(linters ?? {})) {
+        const dirs = Array.isArray(cfg.rulesDir) ? cfg.rulesDir : [cfg.rulesDir];
+        for (const dir of dirs) {
+            if (!dir)
+                continue;
+            const full = (0, node_path_1.resolve)(basePath, dir);
+            if (!(0, node_fs_1.existsSync)(full))
+                continue;
+            for (const f of (0, glob_1.globSync)("*.*", { cwd: full, nodir: true })) {
+                refs.push(`${name}/${f.replace(/\.[^.]+$/, "")}`);
+            }
+        }
+    }
+    return refs;
+}
+/**
+ * Build a JSON Schema for the `vigiles:` frontmatter block from the
+ * project's discovered linter rules. When no rules are discoverable the
+ * `rule` field falls back to a freeform string so the schema never
+ * false-flags a valid reference.
+ */
+function generateSchema(options = {}) {
+    const basePath = options.basePath ?? process.cwd();
+    const { linters } = (0, generate_types_js_1.generateTypes)({ basePath });
+    const ruleNames = new Set();
+    for (const { linter, rules } of linters) {
+        for (const rule of rules) {
+            ruleNames.add(`${linter}/${rule}`);
+            // ESLint also accepts scoped-plugin rules in bare form (the scope is
+            // treated as the linter, e.g. "@typescript-eslint/no-explicit-any").
+            // Emit both so neither form produces a false squiggle.
+            if (linter === "eslint" && rule.includes("/")) {
+                ruleNames.add(rule);
+            }
+        }
+    }
+    for (const ref of customRuleRefs(basePath, options.linters)) {
+        ruleNames.add(ref);
+    }
+    const sorted = [...ruleNames].sort();
+    const ruleSchema = sorted.length > 0 ? { enum: sorted } : { type: "string" };
+    const schema = {
+        $schema: "http://json-schema.org/draft-07/schema#",
+        $id: "https://vigiles.dev/frontmatter.schema.json",
+        title: "vigiles frontmatter",
+        description: "vigiles enforce rules declared in markdown YAML frontmatter (Level 1).",
+        type: "object",
+        properties: {
+            vigiles: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    enforce: {
+                        type: "array",
+                        description: "Linter rules to enforce, verified by `vigiles audit`.",
+                        items: {
+                            type: "object",
+                            additionalProperties: false,
+                            required: ["rule", "why"],
+                            properties: {
+                                rule: {
+                                    description: "Linter rule reference, e.g. eslint/no-console. Verified to exist AND be enabled.",
+                                    ...ruleSchema,
+                                },
+                                why: {
+                                    type: "string",
+                                    description: "Why this rule is enforced — shown to the agent as context.",
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+    return {
+        schema,
+        json: JSON.stringify(schema, null, 2) + "\n",
+        ruleNames: sorted,
+        linters: linters.map((l) => ({ linter: l.linter, count: l.rules.length })),
+    };
+}
+//# sourceMappingURL=generate-schema.js.map