vigiles 32.0.2 → 32.1.1

package/dist/hook-install.d.ts

@@ -1,4 +1,3 @@
-import type { DispatchKind } from "./core/hook-program.js";
 /** The agnostic, committed home for hook SOURCE — one dir, cross-adapter. */
 export declare const HOOKS_DIR = ".vigiles/hooks";
 /** The committed home for registered context-provider SOURCE (v2). */
@@ -73,41 +72,6 @@ export declare function normalizeHookRef(hookPath: string, cwd?: string): string
  * it can be given — see {@link hookGateRef} for the same fallback.
  */
 export declare function hookRuntimeRef(projectRootTokens: readonly string[] | undefined): string;
-/**
- * What the shell must do when the runtime above CANNOT START — a missing
- * `node_modules/vigiles`, an unreadable file, an interpreter that dies before a
- * single line of ours runs. No code of ours executes in that case, so the policy
- * has to be expressed in the emitted command or not at all.
- *
- * 🔴 THIS IS NOT A NEW POLICY. `runHookProgramCommand`'s load-failure branch has
- * decided it since 2026-08: *"an inject's purpose is to ADD context, not to
- * ENFORCE a decision … Gates (file, bash, prompt, stop) remain conservative and
- * fail closed."* That branch only reaches failures that happen AFTER the runtime
- * starts. This carries the same rule one layer out, to the failures that happen
- * before it.
- *
- * WHY THE SPLIT, RATHER THAN ONE ANSWER FOR EVERYTHING — the two failures are
- * not comparable:
- *
- *   A GATE THAT SILENTLY PASSES IS WORSE THAN NO GATE. Its whole value is the
- *   refusal, and a harness that reports protection it is not providing is the
- *   one state worse than admitting it has none. So a gate whose runtime is
- *   missing exits 2: loud, blocking, and the cause is on stderr.
- *
- *   A NUDGE THAT BLOCKS COSTS THE WHOLE REPOSITORY. Measured here 2026-08-10:
- *   merge-conflict markers in `package.json` stopped every hook loading, the
- *   Bash gate then refused `git merge --abort` — the one command that undoes the
- *   cause — and the session could not be repaired from inside. A reminder is
- *   never worth that, so a nudge exits 0 and says nothing it cannot say.
- *
- * The role is not a flag someone can flip: `Reaction` has no `deny` and an
- * inject returns context, so "nudge" is a fact about the TYPE the author chose.
- *
- * (Industry does not agree on one answer either — husky and lefthook skip,
- * pre-commit fails. Which is itself the argument for deciding by role instead
- * of picking one and imposing it on both.)
- */
-export declare function hookRuntimeMissingExit(kind: DispatchKind): 0 | 2;
 export declare function hookGateRef(ref: string, projectRootTokens: readonly string[] | undefined): string;
 /**
  * Idempotently merge a compiled hook's block into an existing `settings.json`

package/dist/hook-install.js

@@ -5,7 +5,6 @@ exports.discoverHookFiles = discoverHookFiles;
 exports.discoverProviderFiles = discoverProviderFiles;
 exports.normalizeHookRef = normalizeHookRef;
 exports.hookRuntimeRef = hookRuntimeRef;
-exports.hookRuntimeMissingExit = hookRuntimeMissingExit;
 exports.hookGateRef = hookGateRef;
 exports.mergeHooksJson = mergeHooksJson;
 exports.mergeHooksToml = mergeHooksToml;
@@ -122,43 +121,6 @@ function hookRuntimeRef(projectRootTokens) {
     const token = projectRootTokens?.[0];
     return token === undefined ? `node ${rel}` : `node "${token}/${rel}"`;
 }
-/**
- * What the shell must do when the runtime above CANNOT START — a missing
- * `node_modules/vigiles`, an unreadable file, an interpreter that dies before a
- * single line of ours runs. No code of ours executes in that case, so the policy
- * has to be expressed in the emitted command or not at all.
- *
- * 🔴 THIS IS NOT A NEW POLICY. `runHookProgramCommand`'s load-failure branch has
- * decided it since 2026-08: *"an inject's purpose is to ADD context, not to
- * ENFORCE a decision … Gates (file, bash, prompt, stop) remain conservative and
- * fail closed."* That branch only reaches failures that happen AFTER the runtime
- * starts. This carries the same rule one layer out, to the failures that happen
- * before it.
- *
- * WHY THE SPLIT, RATHER THAN ONE ANSWER FOR EVERYTHING — the two failures are
- * not comparable:
- *
- *   A GATE THAT SILENTLY PASSES IS WORSE THAN NO GATE. Its whole value is the
- *   refusal, and a harness that reports protection it is not providing is the
- *   one state worse than admitting it has none. So a gate whose runtime is
- *   missing exits 2: loud, blocking, and the cause is on stderr.
- *
- *   A NUDGE THAT BLOCKS COSTS THE WHOLE REPOSITORY. Measured here 2026-08-10:
- *   merge-conflict markers in `package.json` stopped every hook loading, the
- *   Bash gate then refused `git merge --abort` — the one command that undoes the
- *   cause — and the session could not be repaired from inside. A reminder is
- *   never worth that, so a nudge exits 0 and says nothing it cannot say.
- *
- * The role is not a flag someone can flip: `Reaction` has no `deny` and an
- * inject returns context, so "nudge" is a fact about the TYPE the author chose.
- *
- * (Industry does not agree on one answer either — husky and lefthook skip,
- * pre-commit fails. Which is itself the argument for deciding by role instead
- * of picking one and imposing it on both.)
- */
-function hookRuntimeMissingExit(kind) {
-    return kind === "inject" || kind === "react" ? 0 : 2;
-}
 function hookGateRef(ref, projectRootTokens) {
     const token = projectRootTokens?.[0];
     return token === undefined ? ref : `"${token}/${ref}"`;

package/dist/hook-runtime.js

@@ -432,12 +432,16 @@ async function runHookProgramCommand(file) {
         // the author are different from a `deny`'s: name the real cause, and leave a
         // way back.
         //
-        // EXCEPTION: inject hooks. An inject's purpose is to ADD context, not to
-        // ENFORCE a decision. If it fails to load, the session should degrade
-        // gracefully (no context injected) rather than wedging the entire harness.
-        // This is a harness failure, not a gating decision — so we handle it by
-        // logging the error and exiting 0. Gates (file, bash, prompt, stop) remain
-        // conservative and fail closed.
+        // A hook that cannot be loaded always exits 2 here, whatever kind of hook it
+        // is. We cannot tell: the hook did not load, so there is nothing to ask
+        // whether it is a gate (can block) or a nudge (reminder only). This code used
+        // to guess from the file name (`file.includes("inject")`), and the guess
+        // disagreed with the `|| exit N` ending that `vigiles compile` writes on the
+        // command: a nudge without "inject" in its name blocked the session, and a
+        // gate with it let every command through (#312).
+        // Now only that ending decides. A nudge is wired `|| exit 0`, so the shell
+        // turns our 2 into a 0 and it degrades; a gate is wired `|| exit 2` and
+        // blocks. A command with no such ending is treated as a gate, the safe default.
         //
         // Escapes, both announced loudly on stderr:
         //   - the stale-stamp one (an edit to the hook itself / `vigiles compile`),
@@ -476,11 +480,13 @@ async function runHookProgramCommand(file) {
             announceRepairEscape(file, cause);
             return;
         }
-        // Log the error, but for inject hooks, degrade gracefully (exit 0).
         const errorMsg = `vigiles: hook ${file} ${cause}.\n` +
             `vigiles: this is the state of the HARNESS, not a decision about your ` +
             `command — the gate never ran. Blocking anyway (a gate that cannot run ` +
             `must not pass traffic).\n` +
+            `vigiles: if this hook is a NUDGE (an inject or a react), it must not ` +
+            `block: its wiring should end in \`|| exit 0\`, which \`vigiles compile\` ` +
+            `writes. A hook wired by hand with no such ending is treated as a gate.\n` +
             `vigiles: the way out is a FILE WRITE, not a command — under a tool that ` +
             `WRITES (Write/Edit/MultiEdit); a Read of the same path repairs nothing ` +
             `and is refused. Fix whichever of ` +
@@ -493,24 +499,11 @@ async function runHookProgramCommand(file) {
             `repair this failure.\n` +
             `vigiles: no command is allowed, deliberately. \`git merge --abort\` and ` +
             `\`git checkout\` RUN \`.git/hooks/*\` (measured: reference-transaction, ` +
-            `post-checkout), and \`vigiles compile\` loads the hook through the same ` +
-            `resolver that just failed.`;
+            `post-checkout), \`vigiles compile\` loads the hook through the same ` +
+            `resolver that just failed, and an install runs the lifecycle scripts of ` +
+            `every package in the lockfile.`;
         console.error(errorMsg);
-        // Exit code depends on hook kind. This heuristic is based on the filename —
-        // a more robust approach would parse the stamp or metadata, but that requires
-        // the hook to load. Inject hooks typically have "inject" in the name; fall
-        // back to blocking (exit 2) for safety on gates.
-        const isLikelyInject = file.includes("inject");
-        if (isLikelyInject) {
-            // Inject hook: degrade gracefully. Log the error but don't wedge the session.
-            console.error(`vigiles: ${file} is an inject hook; degrading gracefully (no context injected).`);
-            process.exit(0);
-        }
-        else {
-            // Gate hook: fail closed.
-            process.exit(2);
-        }
-        return;
+        process.exit(2);
     }
     verifyStampOrRefuse(file, event);
     switch ((0, hook_program_js_1.dispatchKind)(program)) {

package/dist/instruction-weight-ratchet.d.ts

@@ -0,0 +1,53 @@
+import { type InstructionBaseline, type ParsedBaseline } from "./core/instruction-baseline.js";
+import type { InstructionWeight } from "./core/instruction-weight.js";
+import type { RuleSeverity } from "./core/types.js";
+/** The file on disk, read once: absent, parsed, or refused. */
+export type BaselineOnDisk = {
+    readonly kind: "absent";
+} | ParsedBaseline;
+export declare function readInstructionBaseline(root: string): BaselineOnDisk;
+/** One bundle's measurement: where it is, and its weight (`null` = nothing to weigh). */
+export type MeasuredBundle = readonly [
+    at: string,
+    weight: InstructionWeight | null
+];
+/** Write the baseline for every measured bundle; returns what was written. */
+export declare function writeInstructionBaseline(root: string, onDisk: BaselineOnDisk, measured: readonly MeasuredBundle[]): InstructionBaseline;
+/**
+ * One line of lint output. `finding` counts toward the exit code; `ok` is the
+ * baseline holding; `note` is the opt-in nudge on a repo with no baseline.
+ */
+export interface RatchetLine {
+    readonly at: string;
+    readonly status: "finding" | "ok" | "note";
+    readonly text: string;
+}
+/**
+ * Pure: the lines a run prints, given what was measured and what is on disk.
+ *
+ * A bundle with no entry is a nudge while the repo has NO baseline file (it has
+ * not opted in, and a fresh repo must not fail on day one) — but a FINDING once
+ * the file exists: a bundle that appeared after the baseline was recorded is
+ * weight nobody signed off on.
+ */
+export declare function ratchetLines(onDisk: BaselineOnDisk, measured: readonly MeasuredBundle[]): readonly RatchetLine[];
+/** Run the ratchet for `lint`: print, annotate, count. */
+export declare function checkInstructionWeightRatchet(opts: {
+    readonly root: string;
+    readonly severity: RuleSeverity;
+    readonly update: boolean;
+    readonly silent: boolean;
+    /** Called only when the rule is on or an update was asked for. */
+    readonly measure: () => readonly MeasuredBundle[];
+    readonly annotate: (level: "error" | "warning", message: string) => void;
+}): {
+    issues: number;
+    errors: number;
+};
+/**
+ * The line `compile` prints after writing instruction files: the weight NOW,
+ * against the baseline, at the moment the author changed it. Report-only —
+ * `lint` stays the single gate. `null` when there is nothing to weigh.
+ */
+export declare function compileWeightLine(root: string, weight: InstructionWeight | null): string | null;
+//# sourceMappingURL=instruction-weight-ratchet.d.ts.map

package/dist/instruction-weight-ratchet.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readInstructionBaseline = readInstructionBaseline;
+exports.writeInstructionBaseline = writeInstructionBaseline;
+exports.ratchetLines = ratchetLines;
+exports.checkInstructionWeightRatchet = checkInstructionWeightRatchet;
+exports.compileWeightLine = compileWeightLine;
+/**
+ * `lint`'s side of the instruction-weight ratchet: measure each scored bundle,
+ * compare it with `.vigiles/instruction-weight.json`, and — only under the
+ * explicit `--update-baseline` — write that file.
+ *
+ * The decisions (what a verdict is, what it says) live in
+ * `core/instruction-baseline.ts`; this module owns the two effects the core
+ * must not have, reading and writing the committed file, plus turning verdicts
+ * into lint counters.
+ *
+ * WHY THE FILE IS COMMITTED, unlike `.vigiles/coverage.json`. Coverage records
+ * what tests ran on THIS machine, so a committed copy would credit a checkout
+ * where nothing ran. The baseline records a property of the COMMIT: it is built
+ * from `committedTotal`, which already leaves out every per-machine file
+ * (`CLAUDE.local.md`, a gitignored settings sibling), so two clones of one
+ * commit compute byte-identical files. That is what lets CI compare against it.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const instruction_baseline_js_1 = require("./core/instruction-baseline.js");
+function readInstructionBaseline(root) {
+    const path = (0, node_path_1.join)(root, instruction_baseline_js_1.INSTRUCTION_BASELINE_FILE);
+    return (0, node_fs_1.existsSync)(path)
+        ? (0, instruction_baseline_js_1.parseInstructionBaseline)((0, node_fs_1.readFileSync)(path, "utf-8"))
+        : { kind: "absent" };
+}
+/** Write the baseline for every measured bundle; returns what was written. */
+function writeInstructionBaseline(root, onDisk, measured) {
+    const next = (0, instruction_baseline_js_1.recordEntries)(onDisk.kind === "ok" ? onDisk.baseline : undefined, measured.map(([at, w]) => [at, w === null ? null : (0, instruction_baseline_js_1.entryFor)(w)]));
+    const path = (0, node_path_1.join)(root, instruction_baseline_js_1.INSTRUCTION_BASELINE_FILE);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+    (0, node_fs_1.writeFileSync)(path, (0, instruction_baseline_js_1.serializeBaseline)(next));
+    return next;
+}
+/**
+ * Pure: the lines a run prints, given what was measured and what is on disk.
+ *
+ * A bundle with no entry is a nudge while the repo has NO baseline file (it has
+ * not opted in, and a fresh repo must not fail on day one) — but a FINDING once
+ * the file exists: a bundle that appeared after the baseline was recorded is
+ * weight nobody signed off on.
+ */
+function ratchetLines(onDisk, measured) {
+    if (onDisk.kind === "invalid") {
+        return [
+            {
+                at: ".",
+                status: "finding",
+                text: `${instruction_baseline_js_1.INSTRUCTION_BASELINE_FILE} cannot be read (${onDisk.message}) — ` +
+                    `re-record it with \`${instruction_baseline_js_1.UPDATE_BASELINE_COMMAND}\``,
+            },
+        ];
+    }
+    const recorded = onDisk.kind === "ok" ? onDisk.baseline.bundles : {};
+    return measured.flatMap(([at, weight]) => {
+        if (weight === null)
+            return [];
+        const verdict = (0, instruction_baseline_js_1.compareToBaseline)(weight, Object.hasOwn(recorded, at) ? recorded[at] : undefined);
+        const status = verdict.kind === "held"
+            ? "ok"
+            : verdict.kind === "unrecorded" && onDisk.kind !== "ok"
+                ? "note"
+                : "finding";
+        // An import named and not read is weight this number lacks — a second
+        // hop, or a path that does not resolve. Said on the line itself, because
+        // the gate holding is only as true as the sum it holds.
+        const unfollowed = weight.unreadImports.length > 0
+            ? ` (${String(weight.unreadImports.length)} import(s) not followed: ${weight.unreadImports.join(", ")} — their size is not in this number)`
+            : "";
+        return [{ at, status, text: `${(0, instruction_baseline_js_1.formatVerdict)(verdict, at)}${unfollowed}` }];
+    });
+}
+/** Run the ratchet for `lint`: print, annotate, count. */
+function checkInstructionWeightRatchet(opts) {
+    const { severity, update, silent } = opts;
+    if (!severity && !update)
+        return { issues: 0, errors: 0 };
+    const measured = opts.measure();
+    const before = readInstructionBaseline(opts.root);
+    const onDisk = update
+        ? {
+            kind: "ok",
+            baseline: writeInstructionBaseline(opts.root, before, measured),
+        }
+        : before;
+    const lines = severity ? ratchetLines(onDisk, measured) : [];
+    const findings = lines.filter((l) => l.status === "finding");
+    if (!silent && (update || lines.length > 0)) {
+        console.log("\nInstruction-weight ratchet:\n");
+        if (update)
+            console.log(`  ✓ recorded ${instruction_baseline_js_1.INSTRUCTION_BASELINE_FILE}`);
+        const marks = {
+            finding: severity === "error" ? "✗" : "⚠",
+            ok: "✓",
+            note: "ℹ",
+        };
+        lines.forEach((l) => {
+            console.log(`  ${marks[l.status]} ${l.text}`);
+        });
+    }
+    const level = severity === "error" ? "error" : "warning";
+    findings.forEach((l) => {
+        opts.annotate(level, l.text);
+    });
+    return {
+        issues: findings.length,
+        errors: severity === "error" ? findings.length : 0,
+    };
+}
+/**
+ * The line `compile` prints after writing instruction files: the weight NOW,
+ * against the baseline, at the moment the author changed it. Report-only —
+ * `lint` stays the single gate. `null` when there is nothing to weigh.
+ */
+function compileWeightLine(root, weight) {
+    if (weight === null)
+        return null;
+    const onDisk = readInstructionBaseline(root);
+    if (onDisk.kind === "invalid") {
+        return `always-loaded: ${instruction_baseline_js_1.INSTRUCTION_BASELINE_FILE} cannot be read (${onDisk.message})`;
+    }
+    const recorded = onDisk.kind === "ok" ? onDisk.baseline.bundles : {};
+    return (0, instruction_baseline_js_1.formatWeightLine)((0, instruction_baseline_js_1.compareToBaseline)(weight, Object.hasOwn(recorded, ".") ? recorded["."] : undefined));
+}
+//# sourceMappingURL=instruction-weight-ratchet.js.map

package/dist/local-files.js

@@ -100,6 +100,7 @@ exports.LOCAL_FILES = [
  */
 exports.COMMITTED_PATHS = [
     "hooks", // hook sources + their stamps (`hook-install.ts`)
+    "hook-check.sh", // the start-of-session check, generated by compile (`hook-check.ts`)
     "providers", // registered hook-context providers
     "eval-locks", // committed eval staleness stamps (`eval-lock.ts`)
     "eval-baseline.json", // the committed regression baseline (`eval-baseline.ts`)
@@ -107,6 +108,7 @@ exports.COMMITTED_PATHS = [
     "schema.json", // YAML-LSP frontmatter schema (`vigiles init`)
     "guards.json", // the declared guard set (`core/guards.ts`)
     "action-gates.json", // declared action gates (`action-gate.ts`)
+    "instruction-weight.json", // the instruction-weight ratchet's baseline (`core/instruction-baseline.ts`)
 ];
 /** The header comment on a `.vigiles/.gitignore` vigiles creates. */
 /** The ignore file vigiles keeps inside `.vigiles/`. One spelling for every reader. */

package/dist/scan.d.ts

@@ -411,6 +411,16 @@ export interface ScanHarness {
     readonly dialect: HarnessDialect;
     readonly roots: readonly string[];
 }
+/**
+ * The always-loaded instruction weight of ONE directory under ONE harness —
+ * the bounded read, the harness's chain, and the sum, in one place.
+ *
+ * `scanPlugin` reports it, `lint`'s instruction-weight ratchet gates on it and
+ * `compile` prints it, so all three must arrive at the same number by the same
+ * route; this function is that route. `null` when the harness publishes no
+ * budget (there is no unit to count in).
+ */
+export declare function measureInstructionWeight(dir: string, harness: Pick<ScanHarness, "layout" | "dialect">): InstructionWeight | null;
 /** Scan a plugin/repo directory and report its surfaces + structural issues. */
 export declare function scanPlugin(dir: string, layout: PluginLayout, dialect: HarnessDialect, opts?: {
     sharedDirs?: readonly string[];

package/dist/scan.js

@@ -27,6 +27,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureInstructionWeight = measureInstructionWeight;
 exports.scanPlugin = scanPlugin;
 exports.verifyLiveMcpTools = verifyLiveMcpTools;
 exports.formatMcpContractReport = formatMcpContractReport;
@@ -153,6 +154,25 @@ function ownTestSignalOnDisk(dir) {
         existsSync: node_fs_1.existsSync,
     });
 }
+/**
+ * The always-loaded instruction weight of ONE directory under ONE harness —
+ * the bounded read, the harness's chain, and the sum, in one place.
+ *
+ * `scanPlugin` reports it, `lint`'s instruction-weight ratchet gates on it and
+ * `compile` prints it, so all three must arrive at the same number by the same
+ * route; this function is that route. `null` when the harness publishes no
+ * budget (there is no unit to count in).
+ */
+function measureInstructionWeight(dir, harness) {
+    // No `exclude` parameter, on purpose — see the note in `scanPlugin`.
+    return weighBoundedInstructions(harness, (0, surface_discovery_fs_js_1.boundedInstructionFiles)((0, node_path_1.resolve)(dir), harness.layout));
+}
+function weighBoundedInstructions(harness, instructionFiles) {
+    const budget = harness.dialect.instructionBudget;
+    return budget
+        ? (0, instruction_weight_js_1.weighInstructions)(harness.layout.instructionChain(instructionFiles), instructionFiles, budget)
+        : null;
+}
 /** Scan a plugin/repo directory and report its surfaces + structural issues. */
 function scanPlugin(dir, layout, dialect, opts = {}) {
     const lay = layout;
@@ -195,7 +215,15 @@ function scanPlugin(dir, layout, dialect, opts = {}) {
     // expanded an ADAPTER's globs by walking the whole tree; the bound and the
     // classification are now separate jobs held by separate modules, and only the
     // second is the adapter's. See `core/instruction-chain.ts`.
-    const instructionFiles = (0, surface_discovery_fs_js_1.boundedInstructionFiles)((0, node_path_1.resolve)(dir), instructionHarness.layout, opts.excludes);
+    //
+    // 🔴 `exclude` DOES NOT REACH IT. `exclude` means "vigiles does not lint
+    // this"; the harness still loads the file, so hiding it from the weight
+    // under-reports — and since the weight is a committed baseline, one more
+    // `exclude` line would silently lower the ratchet. The harness's own
+    // `claudeMdExcludes` is the channel that removes a file, because it is also
+    // what stops the harness loading it. The browser twin never applied `exclude`
+    // here either, so this is also where the two engines agree.
+    const instructionFiles = (0, surface_discovery_fs_js_1.boundedInstructionFiles)((0, node_path_1.resolve)(dir), instructionHarness.layout);
     const instructions = loaded.files[instructionFile] !== undefined
         ? {
             file: instructionFile,
@@ -321,9 +349,7 @@ function scanPlugin(dir, layout, dialect, opts = {}) {
         // unit (Claude Code counts 40 000 chars, Codex 32 768 bytes), so there is no
         // meaningful sum across two; reporting the one that owns the file that
         // exists is the only reading that is true of something.
-        instructionWeight: instructionHarness.dialect.instructionBudget
-            ? (0, instruction_weight_js_1.weighInstructions)(instructionHarness.layout.instructionChain(instructionFiles), instructionFiles, instructionHarness.dialect.instructionBudget)
-            : null,
+        instructionWeight: weighBoundedInstructions(instructionHarness, instructionFiles),
         untested: coverage.untested.length,
         untestedHarness: coverage.harness.untested.length,
         unevaluated: coverage.evals.untested.length,

package/dist/vigilesrc.schema.json

@@ -1519,6 +1519,42 @@
               "const": true
             }
           ]
+        },
+        "instruction-weight": {
+          "anyOf": [
+            {
+              "type": "string",
+              "const": "warn"
+            },
+            {
+              "type": "string",
+              "const": "error"
+            },
+            {
+              "type": "boolean",
+              "const": false
+            },
+            {
+              "type": "string",
+              "const": "off"
+            },
+            {
+              "type": "number",
+              "const": 0
+            },
+            {
+              "type": "number",
+              "const": 1
+            },
+            {
+              "type": "number",
+              "const": 2
+            },
+            {
+              "type": "boolean",
+              "const": true
+            }
+          ]
         }
       },
       "additionalProperties": false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigiles",
-  "version": "32.0.2",
+  "version": "32.1.1",
   "description": "Audit, test and measure the harness your AI agent runs on — grade your CLAUDE.md / AGENTS.md, skills, subagents and hooks, run them against a scripted model, and measure whether they actually fire.",
   "keywords": [
     "claude-code",