vigiles 2.0.0 → 2.2.0

package/dist/generate-schema.js

@@ -0,0 +1,125 @@
+"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.",
+                                },
+                            },
+                        },
+                    },
+                    files: {
+                        type: "array",
+                        description: "File paths referenced by this instruction file, verified to exist by `vigiles audit`.",
+                        items: { type: "string" },
+                    },
+                    commands: {
+                        type: "array",
+                        description: "Commands (npm scripts / script-runner invocations) referenced here, verified by `vigiles audit`.",
+                        items: { type: "string" },
+                    },
+                },
+            },
+        },
+    };
+    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

package/dist/generate-types.js

@@ -73,7 +73,7 @@ function discoverEslintRules(basePath) {
         const rules = JSON.parse(output.trim() || "[]");
         if (rules.length === 0)
             return null;
-        return { linter: "eslint", rules, via: "flat config" };
+        return { linter: "eslint", rules, via: "flat config (v9+/v10)" };
     }
     catch {
         return null;
@@ -199,6 +199,41 @@ function discoverRubocopRules(basePath) {
         return null;
     }
 }
+function discoverCedarPolicies(basePath) {
+    const ID_RE = /@id\("([^"]+)"\)/g;
+    const STATEMENT_RE = /\b(?:permit|forbid)\s*\(/;
+    const policies = new Set();
+    for (const dir of [".cedar", "cedar"]) {
+        const fullDir = (0, node_path_1.resolve)(basePath, dir);
+        if (!(0, node_fs_1.existsSync)(fullDir))
+            continue;
+        const files = (0, glob_1.globSync)("**/*.cedar", { cwd: fullDir, nodir: true });
+        for (const file of files) {
+            let content;
+            try {
+                content = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(fullDir, file), "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const annotated = [...content.matchAll(ID_RE)].map((m) => m[1]);
+            if (annotated.length > 0) {
+                for (const id of annotated)
+                    policies.add(id);
+            }
+            else if (STATEMENT_RE.test(content)) {
+                policies.add(file.replace(/\.cedar$/, "").replace(/\\/g, "/"));
+            }
+        }
+    }
+    if (policies.size === 0)
+        return null;
+    return {
+        linter: "cedar",
+        rules: [...policies].sort(),
+        via: ".cedar files",
+    };
+}
 function discoverClippyRules(basePath) {
     try {
         const cargoPath = (0, node_path_1.resolve)(basePath, "Cargo.toml");
@@ -300,6 +335,9 @@ function generateTypes(options = {}) {
     const clippy = discoverClippyRules(basePath);
     if (clippy)
         linters.push(clippy);
+    const cedar = discoverCedarPolicies(basePath);
+    if (cedar)
+        linters.push(cedar);
     const scripts = discoverNpmScripts(basePath);
     const files = discoverProjectFiles(basePath, fileGlobs);
     // Generate .d.ts

package/dist/harness-test.d.ts

@@ -0,0 +1,38 @@
+import { type ModelTurn } from "./mock-model.js";
+export { scriptModel, type ModelTurn } from "./mock-model.js";
+export interface HarnessTestSpec {
+    /** Fixture files to write in a fresh temp working dir (path → contents). */
+    readonly files?: Record<string, string>;
+    /** `.claude/settings.json` contents — the hooks/permissions under test. */
+    readonly settings?: unknown;
+    /** The scripted model turns the agent will take. */
+    readonly model: readonly ModelTurn[];
+    /** The user prompt. Default: "go". */
+    readonly prompt?: string;
+    /** Tools the agent may use. Default: Read Edit Write Bash. */
+    readonly allowedTools?: readonly string[];
+    /** Per-run wall-clock timeout in ms. Default 60000. */
+    readonly timeoutMs?: number;
+}
+export interface HarnessTestResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    /** Hook block messages and diagnostics land here. */
+    readonly stderr: string;
+    /** The temp working dir (inspect or clean it up). */
+    readonly cwd: string;
+    /** Number of model turns the agent took (mock turns served). */
+    readonly turns: number;
+    /** Final contents of a file under the working dir, or null if absent. */
+    file(path: string): string | null;
+    /** Remove the temp working dir. */
+    cleanup(): void;
+}
+/** Whether the `claude` CLI is available — harness tests need it. */
+export declare function claudeAvailable(): boolean;
+/**
+ * Run the real `claude` CLI against a scripted mock model, with the given
+ * fixture and settings (hooks). Deterministic — same script, same result.
+ */
+export declare function runHarnessTest(spec: HarnessTestSpec): Promise<HarnessTestResult>;
+//# sourceMappingURL=harness-test.d.ts.map

package/dist/harness-test.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptModel = void 0;
+exports.claudeAvailable = claudeAvailable;
+exports.runHarnessTest = runHarnessTest;
+/**
+ * vigiles — deterministic Claude Code harness testing.
+ *
+ * Test what your *harness* does — hooks, settings, skills, instruction files —
+ * without paying for or depending on a real model. `runHarnessTest` spins up the
+ * real `claude` CLI (so your real hooks and settings fire exactly as in
+ * production) but points it at a scripted mock model (`src/mock-model.ts`), so
+ * the agent's turns are fixed and the outcome is reproducible. No API key, no
+ * cost, CI-friendly.
+ *
+ *   const r = await runHarnessTest({
+ *     settings: { hooks: { Stop: [{ hooks: [{ type: "command",
+ *       command: "test -f DONE || { echo 'not done' >&2; exit 2; }" }] }] } },
+ *     model: scriptModel([
+ *       { text: "I'm done" },                              // tries to stop → blocked
+ *       { tool: "Bash", input: { command: "touch DONE" } },
+ *       { text: "now done" },
+ *     ]),
+ *   });
+ *   assert(JSON.parse(r.stdout).num_turns > 1);            // the Stop hook fired
+ *
+ * The "steps" are the scripted model turns — their real home is deterministic
+ * harness testing, not production enforcement.
+ *
+ * Note: the simple mock drives the Bash tool and Stop hooks reliably; the
+ * Edit/Write tools are gated in headless mode and don't fire via the mock —
+ * drive file actions through Bash, or use the real-model eval tier (`eval.ts`)
+ * for Edit/Write hooks.
+ */
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const mock_model_js_1 = require("./mock-model.js");
+var mock_model_js_2 = require("./mock-model.js");
+Object.defineProperty(exports, "scriptModel", { enumerable: true, get: function () { return mock_model_js_2.scriptModel; } });
+/** Whether the `claude` CLI is available — harness tests need it. */
+function claudeAvailable() {
+    try {
+        return (0, node_child_process_1.spawnSync)("claude", ["--version"], { stdio: "ignore" }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function writeFixture(cwd, spec) {
+    for (const [p, content] of Object.entries(spec.files ?? {})) {
+        const full = (0, node_path_1.resolve)(cwd, p);
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(full), { recursive: true });
+        (0, node_fs_1.writeFileSync)(full, content);
+    }
+    if (spec.settings !== undefined) {
+        // `{cwd}` in any hook command is substituted with the working dir, so a
+        // hook can reference an absolute path inside it (hooks don't run with the
+        // project dir as cwd).
+        const json = JSON.stringify(spec.settings, null, 2).replaceAll("{cwd}", cwd);
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(cwd, "settings.json"), json);
+    }
+}
+function spawnClaude(args, cwd, baseUrl, timeoutMs) {
+    return new Promise((resolvePromise) => {
+        const child = (0, node_child_process_1.spawn)("claude", args, {
+            cwd,
+            env: {
+                ...process.env,
+                ANTHROPIC_BASE_URL: baseUrl,
+                // Any value works — the mock ignores auth; this avoids needing a real key.
+                ANTHROPIC_API_KEY: "sk-vigiles-mock",
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => (stdout += d.toString()));
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolvePromise({ code: code ?? 0, stdout, stderr });
+        });
+    });
+}
+/**
+ * Run the real `claude` CLI against a scripted mock model, with the given
+ * fixture and settings (hooks). Deterministic — same script, same result.
+ */
+async function runHarnessTest(spec) {
+    const cwd = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "vigiles-harness-"));
+    writeFixture(cwd, spec);
+    const mock = await (0, mock_model_js_1.startMock)(spec.model);
+    try {
+        const tools = spec.allowedTools ?? ["Read", "Edit", "Write", "Bash"];
+        const args = [
+            "-p",
+            spec.prompt ?? "go",
+            "--output-format",
+            "json",
+            "--model",
+            "claude-sonnet-4-5",
+            ...(spec.settings !== undefined ? ["--settings", "settings.json"] : []),
+            "--allowedTools",
+            ...tools,
+        ];
+        const out = await spawnClaude(args, cwd, mock.url, spec.timeoutMs ?? 60000);
+        return {
+            exitCode: out.code,
+            stdout: out.stdout,
+            stderr: out.stderr,
+            cwd,
+            turns: mock.count,
+            file: (p) => {
+                const f = (0, node_path_1.resolve)(cwd, p);
+                return (0, node_fs_1.existsSync)(f) ? (0, node_fs_1.readFileSync)(f, "utf-8") : null;
+            },
+            cleanup: () => {
+                (0, node_fs_1.rmSync)(cwd, { recursive: true, force: true });
+            },
+        };
+    }
+    finally {
+        mock.close();
+    }
+}
+//# sourceMappingURL=harness-test.js.map

package/dist/hash.d.ts

@@ -0,0 +1,8 @@
+declare const __brand: unique symbol;
+export type SHA256Hash = string & {
+    readonly [__brand]: "SHA256Hash";
+};
+export declare function sha256short(data: string | Buffer): SHA256Hash;
+export declare function assertNever(x: never): never;
+export {};
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256short = sha256short;
+exports.assertNever = assertNever;
+const node_crypto_1 = require("node:crypto");
+const HASH_LENGTH = 16;
+function sha256short(data) {
+    return (0, node_crypto_1.createHash)("sha256")
+        .update(data)
+        .digest("hex")
+        .slice(0, HASH_LENGTH);
+}
+function assertNever(x) {
+    throw new Error(`Unexpected value: ${String(x)}`);
+}
+//# sourceMappingURL=hash.js.map

package/dist/inline.d.ts

@@ -25,8 +25,24 @@ export interface InlineRule {
     /** 1-based line number of the comment in the source file. */
     line: number;
 }
+/** A `<!-- vigiles:file <path> -->` reference (verified to exist). */
+export interface InlineFileRef {
+    /** Project-relative path to verify exists. */
+    path: string;
+    /** 1-based line number of the comment in the source file. */
+    line: number;
+}
+/** A `<!-- vigiles:cmd "<command>" -->` reference (npm scripts verified). */
+export interface InlineCmdRef {
+    /** Command to verify (npm scripts checked against package.json). */
+    command: string;
+    /** 1-based line number of the comment in the source file. */
+    line: number;
+}
 export interface InlineParseResult {
     rules: InlineRule[];
+    files: InlineFileRef[];
+    commands: InlineCmdRef[];
     /** Lines that look like vigiles: markers but failed to parse. */
     errors: {
         line: number;
@@ -46,13 +62,15 @@ export interface InlineParseResult {
  */
 export declare function parseInlineRules(content: string): InlineParseResult;
 /**
- * True if the content contains at least one parseable vigiles:enforce
- * rule (ignoring fenced code blocks and malformed markers). Used by
- * `require-spec` validation to treat inline mode as spec-equivalent.
+ * True if the content contains at least one parseable vigiles inline marker —
+ * an `enforce` rule, a `file` reference, or a `cmd` reference (ignoring fenced
+ * code blocks and malformed markers). Used by `require-spec` validation to
+ * treat inline mode as spec-equivalent: a file that pins even a single path is
+ * meaningfully managed.
  *
  * Deliberately delegates to `parseInlineRules` so a loose prefix regex
  * can't satisfy require-spec with a malformed marker that produces no
- * real enforceable rule.
+ * real reference.
  */
 export declare function hasInlineRules(content: string): boolean;
 //# sourceMappingURL=inline.d.ts.map

package/dist/inline.js

@@ -29,6 +29,17 @@ exports.hasInlineRules = hasInlineRules;
  * embedded quotes, they can move to spec mode.
  */
 const ENFORCE_RE = /<!--\s*vigiles:enforce\s+([@A-Za-z0-9_/:.-]+)\s+"([^"\n]*)"\s*-->/;
+/**
+ * Match `<!-- vigiles:file <path> -->`. The path is a single whitespace-free
+ * token (project-relative); spaces in paths are vanishingly rare and would be
+ * ambiguous against the closing `-->`.
+ */
+const FILE_RE = /<!--\s*vigiles:file\s+(\S+)\s*-->/;
+/**
+ * Match `<!-- vigiles:cmd "<command>" -->`. The command is quoted because
+ * commands contain spaces (e.g. `npm run build`).
+ */
+const CMD_RE = /<!--\s*vigiles:cmd\s+"([^"\n]*)"\s*-->/;
 /**
  * Detects any `<!-- vigiles:<kind> -->` comment (valid or not) so we can
  * surface errors for typos and reserved-but-unrecognized kinds. Uses a
@@ -36,6 +47,16 @@ const ENFORCE_RE = /<!--\s*vigiles:enforce\s+([@A-Za-z0-9_/:.-]+)\s+"([^"\n]*)"\
  * circuit the pattern.
  */
 const MARKER_RE = /<!--\s*vigiles:([A-Za-z_-]+)[^]*?-->/;
+// vigiles markers handled by other subsystems (skill runtime gates, opt-outs).
+// The inline *rule* parser skips them rather than flagging them as unknown.
+const KNOWN_NON_RULE_MARKERS = new Set([
+    "disable",
+    "ignore",
+    "ignore-file",
+    "gate", // skill step gate (src/skill-runtime.ts)
+    "result", // skill result gate
+    "symbol", // symbol reference mark (src/refs.ts)
+]);
 /**
  * Parse inline vigiles rules out of a markdown file's contents.
  * Does not touch the filesystem and does not verify the rules against
@@ -48,6 +69,8 @@ const MARKER_RE = /<!--\s*vigiles:([A-Za-z_-]+)[^]*?-->/;
  */
 function parseInlineRules(content) {
     const rules = [];
+    const files = [];
+    const commands = [];
     const errors = [];
     const lines = content.split("\n");
     let fenceChar = null;
@@ -97,15 +120,24 @@ function parseInlineRules(content) {
             });
             continue;
         }
+        const fileMatch = FILE_RE.exec(scannable);
+        if (fileMatch) {
+            files.push({ path: fileMatch[1], line: i + 1 });
+            continue;
+        }
+        const cmdMatch = CMD_RE.exec(scannable);
+        if (cmdMatch) {
+            commands.push({ command: cmdMatch[1], line: i + 1 });
+            continue;
+        }
         // Skip the compiled-file hash header (`<!-- vigiles:sha256:... -->`)
         // entirely — it's not a rule marker and should not be reported.
         if (/<!--\s*vigiles:sha\d+:/.test(scannable))
             continue;
         const markerMatch = MARKER_RE.exec(scannable);
         if (markerMatch) {
-            // Looks like a vigiles marker but didn't parse as enforce —
-            // surface it so users catch typos like "vigile:enforce" or
-            // unquoted why.
+            // Looks like a vigiles marker but didn't parse — surface it so users
+            // catch typos like "vigile:enforce" or an unquoted why/command.
             const kind = markerMatch[1];
             if (kind === "enforce") {
                 errors.push({
@@ -114,29 +146,44 @@ function parseInlineRules(content) {
                     raw: line.trim(),
                 });
             }
-            else if (kind !== "disable" && kind !== "ignore") {
-                // `vigiles:disable ...` / `vigiles:ignore ...` are reserved for
-                // future disable-comment support; don't complain about them.
+            else if (kind === "file") {
+                errors.push({
+                    line: i + 1,
+                    message: "Malformed vigiles:file — expected `<!-- vigiles:file <path> -->`",
+                    raw: line.trim(),
+                });
+            }
+            else if (kind === "cmd") {
+                errors.push({
+                    line: i + 1,
+                    message: 'Malformed vigiles:cmd — expected `<!-- vigiles:cmd "<command>" -->`',
+                    raw: line.trim(),
+                });
+            }
+            else if (!KNOWN_NON_RULE_MARKERS.has(kind)) {
                 errors.push({
                     line: i + 1,
-                    message: `Unknown vigiles marker "${kind}". Only \`vigiles:enforce\` is supported.`,
+                    message: `Unknown vigiles marker "${kind}". Only \`vigiles:enforce\`, \`vigiles:file\`, and \`vigiles:cmd\` are supported.`,
                     raw: line.trim(),
                 });
             }
         }
     }
-    return { rules, errors };
+    return { rules, files, commands, errors };
 }
 /**
- * True if the content contains at least one parseable vigiles:enforce
- * rule (ignoring fenced code blocks and malformed markers). Used by
- * `require-spec` validation to treat inline mode as spec-equivalent.
+ * True if the content contains at least one parseable vigiles inline marker —
+ * an `enforce` rule, a `file` reference, or a `cmd` reference (ignoring fenced
+ * code blocks and malformed markers). Used by `require-spec` validation to
+ * treat inline mode as spec-equivalent: a file that pins even a single path is
+ * meaningfully managed.
  *
  * Deliberately delegates to `parseInlineRules` so a loose prefix regex
  * can't satisfy require-spec with a malformed marker that produces no
- * real enforceable rule.
+ * real reference.
  */
 function hasInlineRules(content) {
-    return parseInlineRules(content).rules.length > 0;
+    const r = parseInlineRules(content);
+    return r.rules.length + r.files.length + r.commands.length > 0;
 }
 //# sourceMappingURL=inline.js.map

package/dist/integrity.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Integrity check: verify a compiled markdown file hasn't been hand-edited.
+ *
+ * Every compiled file has a SHA-256 hash in its first line:
+ *   <!-- vigiles:sha256:<hash> compiled from CLAUDE.md.spec.ts -->
+ *
+ * If the body content's hash no longer matches what's recorded, someone
+ * edited the compiled output directly. The check is one-pass and ~free.
+ *
+ * This is the entire freshness story now: no input fingerprinting, no
+ * recompile diffing. Those responsibilities belong elsewhere:
+ *
+ * - Hand-edit detection → this module
+ * - "Did the spec change?" → guard() rules emitting compile hooks
+ * - "Are referenced linter rules / files / scripts still valid?"
+ *   → enforce() / file() / cmd() catch this at compile time
+ * - "Are committed compiled files actually fresh?"
+ *   → CI runs `vigiles compile` then `git diff --exit-code`
+ */
+export interface IntegrityResult {
+    intact: boolean;
+    reason?: string;
+}
+/**
+ * Check whether the compiled markdown's SHA-256 hash matches its body.
+ * Files without a hash header are treated as hand-written (intact).
+ */
+export declare function checkIntegrity(content: string): IntegrityResult;
+//# sourceMappingURL=integrity.d.ts.map

package/dist/integrity.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Integrity check: verify a compiled markdown file hasn't been hand-edited.
+ *
+ * Every compiled file has a SHA-256 hash in its first line:
+ *   <!-- vigiles:sha256:<hash> compiled from CLAUDE.md.spec.ts -->
+ *
+ * If the body content's hash no longer matches what's recorded, someone
+ * edited the compiled output directly. The check is one-pass and ~free.
+ *
+ * This is the entire freshness story now: no input fingerprinting, no
+ * recompile diffing. Those responsibilities belong elsewhere:
+ *
+ * - Hand-edit detection → this module
+ * - "Did the spec change?" → guard() rules emitting compile hooks
+ * - "Are referenced linter rules / files / scripts still valid?"
+ *   → enforce() / file() / cmd() catch this at compile time
+ * - "Are committed compiled files actually fresh?"
+ *   → CI runs `vigiles compile` then `git diff --exit-code`
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIntegrity = checkIntegrity;
+const hash_js_1 = require("./hash.js");
+const HASH_LINE_RE = /^<!-- vigiles:sha256:([a-f0-9]+) compiled from (.+) -->\r?\n\r?\n?/;
+/**
+ * Check whether the compiled markdown's SHA-256 hash matches its body.
+ * Files without a hash header are treated as hand-written (intact).
+ */
+function checkIntegrity(content) {
+    const match = content.match(HASH_LINE_RE);
+    if (!match) {
+        return { intact: true, reason: "No hash header (hand-written file)" };
+    }
+    const expectedHash = match[1];
+    const body = content.replace(HASH_LINE_RE, "");
+    if ((0, hash_js_1.sha256short)(body) !== expectedHash) {
+        return {
+            intact: false,
+            reason: "Compiled file was modified directly — edit the .spec.ts source and recompile",
+        };
+    }
+    return { intact: true };
+}
+//# sourceMappingURL=integrity.js.map

package/dist/linters.d.ts

@@ -3,10 +3,11 @@
  *
  * Verifies that linter rule references (e.g., "eslint/no-console") point to
  * real rules that exist and are enabled in project config. Supports:
- *   ESLint, Stylelint (Node API), Ruff, Clippy, Pylint, RuboCop (CLI).
+ *   ESLint, Stylelint (Node API), Ruff, Clippy, Pylint, RuboCop (CLI),
+ *   Cedar (filesystem policies for AWS Bedrock AgentCore / Vectimus).
  *
- * This is the core moat — no other tool resolves rules against 6 linter APIs
- * and checks config-enabled status.
+ * This is the core moat — no other tool resolves rules across 7 catalog APIs
+ * (6 linters + Cedar policy language) and checks config-enabled status.
  */
 export type ConfigEnabledStatus = "enabled" | "disabled" | "unknown";
 export interface LinterCheckResult {
@@ -23,6 +24,7 @@ export interface DetectedLinter {
 }
 /** @internal */ export declare function extractLinterName(enforcedBy: string): string;
 /** @internal */ export declare function extractRuleName(enforcedBy: string): string | null;
+/** @internal */ export declare function clearCedarCache(): void;
 /**
  * Check a single linter rule reference (e.g., "eslint/no-console").
  *