vigiles 28.0.0 → 29.0.0

package/dist/cli-main.js

@@ -34,6 +34,7 @@ const setup_plan_js_1 = require("./setup-plan.js");
 const types_js_1 = require("./core/types.js");
 const test_coverage_js_1 = require("./test-coverage.js");
 const scan_js_1 = require("./scan.js");
+const surface_discovery_js_1 = require("./core/surface-discovery.js");
 const scan_trigger_suggest_js_1 = require("./scan-trigger-suggest.js");
 const dialect_drift_js_1 = require("./dialect-drift.js");
 const skill_reachability_js_1 = require("./skill-reachability.js");
@@ -553,7 +554,7 @@ async function compile(specPaths, config, excludes, opts = {}) {
     // dialect pick and the mirror from it — no re-parsing, no cwd-sniffing in the
     // helpers. A loud notice (never a silent guess) on a multi-harness or
     // ambiguous-detection pick.
-    const declaredHarnesses = (0, adapter_registry_js_1.normalizeHarnessList)(config.harness);
+    const declaredHarnesses = (0, adapter_registry_js_1.declaredHarnessNames)(config.harnesses);
     const selection = (0, adapter_registry_js_1.resolveHarnessSelection)({
         root: process.cwd(),
         flag: opts.harnessFlag,
@@ -1466,7 +1467,7 @@ async function runLint(restArgs, flags, excludes, config) {
     const lintSelection = (0, adapter_registry_js_1.resolveHarnessSelection)({
         root: scanRoot,
         flag: harnessFlag,
-        configHarness: (0, adapter_registry_js_1.normalizeHarnessList)(config?.harness),
+        configHarness: (0, adapter_registry_js_1.declaredHarnessNames)(config?.harnesses),
     });
     const adapter = lintSelection.adapter;
     // 🔴 WHICH ROOTS GET SCORED, and saying so either way (#185).
@@ -3363,7 +3364,7 @@ async function setup(args) {
     // Detect project. An existing `.vigilesrc.json` `harness` (from a prior init /
     // a hand-authored config) wins over auto-detection (dogfood I3).
     const detected = detectProject();
-    const harnesses = resolveHarnesses(parsed, detected, (0, validate_js_1.loadConfig)().harness);
+    const harnesses = resolveHarnesses(parsed, detected, (0, adapter_registry_js_1.declaredHarnessNames)((0, validate_js_1.loadConfig)().harnesses));
     printDetection(detected, harnesses);
     // Files actually written, accumulated for an honest commit hint.
     const written = [];
@@ -3436,15 +3437,15 @@ async function setup(args) {
         console.log("\nℹ Ran the standard setup. Already have a harness, or not a JS/Python repo, and want only the CI integrity gate (nothing installed)? Re-run `npx vigiles init --ci-only`.");
     }
 }
-/** Canonical, de-duplicated harness list → a config value (string when one). */
-function harnessConfigValue(harnesses) {
-    const canon = [...new Set(harnesses.map(adapter_registry_js_1.normalizeHarnessName))];
-    return canon.length === 1 ? canon[0] : canon;
+/** Canonical, de-duplicated harness names — the keys `harnesses` gets. */
+function harnessConfigKeys(harnesses) {
+    return [...new Set(harnesses.map(adapter_registry_js_1.normalizeHarnessName))];
 }
 /**
  * Merge the resolved harness(es) (and strict rule severities) into
- * `.vigilesrc.json` without clobbering existing keys — an existing `harness`
- * stays, a missing one is added, a malformed file is left untouched.
+ * `.vigilesrc.json` without clobbering existing keys — an existing
+ * `harnesses` block stays, a missing one is added, a malformed file is left
+ * untouched.
  */
 function writeProjectConfig(opts) {
     const configPath = (0, node_path_1.resolve)(process.cwd(), ".vigilesrc.json");
@@ -3459,7 +3460,7 @@ function writeProjectConfig(opts) {
         }
     }
     const merged = (0, setup_plan_js_1.mergeProjectConfig)(existing, {
-        harness: harnessConfigValue(opts.harnesses),
+        harnesses: harnessConfigKeys(opts.harnesses),
         strict: opts.strict,
         reportOnly: opts.reportOnly,
         lint: opts.lint,
@@ -3524,7 +3525,7 @@ function harnessLayoutFor(root, config, flag) {
         return (0, adapter_registry_js_1.resolveHarnessSelection)({
             root,
             flag,
-            configHarness: (0, adapter_registry_js_1.normalizeHarnessList)(config?.harness),
+            configHarness: (0, adapter_registry_js_1.declaredHarnessNames)(config?.harnesses),
         }).adapter.layout;
     }
     catch {
@@ -4391,7 +4392,7 @@ function flagValue(args, name) {
  * Resolve the adapter for a COMMAND, honouring the full precedence: `--harness=`
  * flag → `.vigilesrc.json` `harness` → auto-detect (dogfood A/I3). This is the
  * ONE resolution path a command may use — resolving via the raw auto-detect
- * alone silently ignores config.harness, which is the exact bug this closes.
+ * alone silently ignores `.vigilesrc.json#harnesses`, which is the exact bug this closes.
  * A dogfood test (src/cli-harness-resolution.test.ts) asserts cli.ts routes all
  * command harness resolution through here, so a future command can't regress.
  */
@@ -4399,7 +4400,7 @@ function resolveCommandHarness(dir, harnessFlag) {
     return (0, adapter_registry_js_1.resolveHarnessSelection)({
         root: dir,
         flag: harnessFlag,
-        configHarness: (0, adapter_registry_js_1.normalizeHarnessList)((0, validate_js_1.loadConfig)().harness),
+        configHarness: (0, adapter_registry_js_1.declaredHarnessNames)((0, validate_js_1.loadConfig)().harnesses),
     });
 }
 async function handleMeasure(restArgs, args) {
@@ -5690,7 +5691,11 @@ function evalLockNudgeHookCommand() {
     // second gate saying the same thing is a branch no test can distinguish from
     // its absence (measured — the mutation passed), i.e. the dead-fragment class
     // this same change removed from the runner table.
-    const config = (0, validate_js_1.loadConfig)(cwd);
+    // `onInvalid: "warn"` — a HOOK RAIL. This is a fresh process inside somebody's
+    // editing session, and a malformed `.vigilesrc.json` must not turn a JSON typo
+    // into a failed edit: the nudge not firing is the cheaper failure. The verbs
+    // throw on the same config; what is CHECKED is identical.
+    const config = (0, validate_js_1.loadConfig)(cwd, { onInvalid: "warn" });
     const { options } = untestedRules(config);
     // 🔴 THE SAME LAYOUT `vigiles lint` RESOLVES, for the same reason as the config
     // above. This used to pass `basePath` alone, so the detector fell back to the
@@ -5756,7 +5761,8 @@ function refsHookCommand() {
     // Root first: the config read below is anchored on it, and reading the config
     // from the process's directory is how a disabled rule comes back to life.
     const cwd = runtimeRoot(eventRoot(raw));
-    const severity = (0, types_js_1.ruleSeverity)((0, validate_js_1.loadConfig)(cwd).rules["unmarked-refs"]);
+    // A hook rail — see `evalLockNudgeHookCommand` for why it warns, not throws.
+    const severity = (0, types_js_1.ruleSeverity)((0, validate_js_1.loadConfig)(cwd, { onInvalid: "warn" }).rules["unmarked-refs"]);
     if (severity === false)
         return;
     const target = (0, node_path_1.relative)(cwd, (0, node_path_1.resolve)(cwd, file)) || file;
@@ -5930,7 +5936,7 @@ async function installHookFile(file, adapter, registeredProviders = []) {
  * harness-neutral, so when a repo targets both harnesses the SAME hook is merged
  * into `.claude/settings.json` AND `.codex/config.toml` (each in its native
  * format, with per-harness warnings) — never just the first. The harness set is
- * resolved from the `--harness=` flag, else `config.harness`, else auto-detect.
+ * resolved from the `--harness=` flag, else `.vigilesrc.json#harnesses`, else auto-detect.
  * Returns false if any hook failed to compile for any harness.
  */
 async function installHooks(hookFiles, harnessFlag, configHarness) {
@@ -6450,7 +6456,8 @@ async function main() {
             if (specs.length > 0)
                 valid =
                     (await compile(specs, config, excludes, { harnessFlag })) && valid;
-            valid = (await installHooks(hooks, harnessFlag, config.harness)) && valid;
+            valid =
+                (await installHooks(hooks, harnessFlag, (0, adapter_registry_js_1.declaredHarnessNames)(config.harnesses))) && valid;
             // Keep an existing whole-harness registry in sync (cheap, opt-in) so the
             // user never hand-runs `generate-harness`. Skipped when no harness.gen.ts.
             if (specs.length > 0)
@@ -6578,19 +6585,74 @@ async function main() {
                 const harnessFlag = harnessFlagFrom(args);
                 // Honor the SAME precedence as lint/compile (dogfood A): --harness= flag,
                 // else the `.vigilesrc.json` `harness` key, else auto-detect. Previously
-                // audit auto-detected and IGNORED config.harness, so a repo that
-                // config-declares `"harness": "codex"` but carries a CLAUDE.md was still
+                // audit auto-detected and IGNORED the declared harnesses, so a repo
+                // that config-declares `"harnesses": {"codex": {}}` but carries a CLAUDE.md was still
                 // scanned as Claude Code. `resolveHarnessSelection` also carries the
                 // ambiguity/multi-target `notice` so the warning stays consistent.
                 const selection = (0, adapter_registry_js_1.resolveHarnessSelection)({
                     root,
                     flag: harnessFlag,
-                    configHarness: (0, adapter_registry_js_1.normalizeHarnessList)(config.harness),
+                    configHarness: (0, adapter_registry_js_1.declaredHarnessNames)(config.harnesses),
                 });
                 const adapter = selection.adapter;
+                // EVERY declared harness, each with the roots declared under it — the
+                // list the scan reads WHOLE. The flag still wins (an explicit override
+                // is singular, and the user typed it), and a repo with no declaration
+                // scans under the one detected adapter exactly as before.
+                //
+                // The PRIMARY is `adapter`, so the report is still labelled and
+                // dialect-checked by one harness; the list is what stops the OTHER
+                // declared harness's skills and instruction file from being invisible.
+                const scanHarnesses = harnessFlag === undefined || harnessFlag === ""
+                    ? (0, adapter_registry_js_1.resolveDeclaredHarnesses)(root, config.harnesses)
+                        .map((d) => ({
+                        layout: d.adapter.layout,
+                        dialect: d.adapter.dialect,
+                        roots: d.roots,
+                    }))
+                        // The primary first, whatever order the object was written in:
+                        // `resolveHarnessSelection` already decided which harness this
+                        // report is FOR, and the scan's first entry is the one that
+                        // supplies the dialect. Two different answers to "which is
+                        // primary" is the bug this change exists to remove.
+                        .sort((a, b) => a.layout.name === adapter.layout.name
+                        ? -1
+                        : b.layout.name === adapter.layout.name
+                            ? 1
+                            : 0)
+                    : [];
+                // A declared root under a harness that reads no surface there is
+                // REFUSED, not ignored. It is the one silent state the nested shape
+                // would otherwise keep: the line changes nothing, and saying nothing is
+                // the tool agreeing with a belief that is false.
+                const badRoots = (0, surface_discovery_js_1.unresolvedDeclaredRoots)(scanHarnesses.map((h) => ({
+                    harness: h.layout.name,
+                    layout: h.layout,
+                    roots: h.roots,
+                })), (rel) => {
+                    const abs = (0, node_path_1.resolve)(root, rel);
+                    return ((0, node_fs_1.lstatSync)(abs, { throwIfNoEntry: false })?.isDirectory() === true);
+                });
+                if (badRoots.length > 0) {
+                    for (const msg of badRoots)
+                        console.error(`✗ ${msg}`);
+                    process.exitCode = 2;
+                    return;
+                }
                 const report = (0, scan_js_1.scanPlugin)(targets[0], adapter.layout, adapter.dialect, {
                     sharedDirs: config.sharedDirs,
                     sharedDirsRoot: sharedDirsRootFor(targets[0]),
+                    // `.vigilesrc.json#exclude` reaches surface DISCOVERY, not just the
+                    // instruction file. Measured 2026-09-21 before this line existed: a repo
+                    // with `{"exclude": [".claude"]}` and one skill at `.claude/skills/demo`
+                    // still printed `Skills (1): ✓ demo` and docked Safety to 90 for it — the
+                    // grade was computed over a tree the user had told the tool to ignore.
+                    excludes,
+                    // The repo owner's answer to "N skills no harness reads": these are
+                    // mine, grade them — each root under the harness whose layout reads
+                    // it, so no array order decides which half of the repo is seen.
+                    // `exclude` still wins over it; the walk drops an excluded path first.
+                    harnesses: scanHarnesses,
                 });
                 if (!json) {
                     console.log(`Detected harness: ${adapter.name}`);

package/dist/core/adapter.d.ts

@@ -115,5 +115,28 @@ export interface HarnessAdapter {
      * `AGENTS.md` that many harnesses share) regardless of registration order.
      */
     detect(root: string): number;
+    /**
+     * Is this repo-relative path one THIS harness reads — "is it mine?"
+     *
+     * 🔴 THE POINT OF THIS METHOD IS WHAT IT CANNOT DO. It takes a path and
+     * returns a boolean: no root, no filesystem, no enumeration. An adapter can
+     * therefore LABEL a surface the domain already found and nothing else —
+     * **registering a new adapter cannot make vigiles read more in anyone's
+     * repository.** The rejected alternative was each adapter DECLARING roots for
+     * the audit to walk, which inverts that: shipping a Cursor adapter would start
+     * reading `.cursor/rules` in every user's repo, and a surface no adapter
+     * declared would stay invisible. Discovery is the domain's job
+     * (`core/surface-discovery.ts`); a claim is an adapter's. See
+     * `research/audit-harness-dx.md` §9.
+     *
+     * The consequence the audit reports: a surface NO registered adapter claims is
+     * a FINDING, not silence — measured on a real repo whose 37 skills under
+     * `.ai/` graded A (100/100) precisely because nothing read them (#240).
+     *
+     * Every shipped adapter implements this as `layoutClaims(<its layout>, path)`,
+     * so a layout that moves takes its claim with it and the two cannot drift.
+     * Override it only for a location the `PluginLayout` fields cannot express.
+     */
+    claims(path: string): boolean;
 }
 //# sourceMappingURL=adapter.d.ts.map

package/dist/core/compile.js

@@ -172,13 +172,23 @@ function validateSymbolRef(file, name, basePath) {
             path: file,
         };
     }
-    if ((0, symbols_js_1.langForFile)(file) === null) {
+    const support = (0, symbols_js_1.langForFile)(file);
+    if (support.kind === "unsupported") {
         return {
             type: "stale-ref",
             message: `Unsupported language for symbol check: "${file}"`,
             path: file,
         };
     }
+    if (support.kind === "grammar-missing") {
+        // The language is parseable by this tool; the optional grammar is absent in THIS install.
+        // Distinct wording on purpose — see the union's docblock in core/symbols.ts.
+        return {
+            type: "stale-ref",
+            message: `Symbol not checked: the ${support.id} grammar is not installed (npm i -D ${support.pkg})`,
+            path: file,
+        };
+    }
     if (!(0, symbols_js_1.fileDefinesSymbol)(full, name)) {
         return {
             type: "stale-ref",

package/dist/core/config-schema.d.ts

@@ -0,0 +1,244 @@
+/**
+ * `.vigilesrc.json`, AS A SCHEMA — the one place the config's shape, its
+ * defaults and its error messages live.
+ *
+ * 🔴 WHY A SCHEMA AND NOT THE HAND-WRITTEN CHECKS IT REPLACED. `loadConfig` used
+ * to coerce the keys it happened to remember (`asStringArray` on three of them),
+ * spread everything else through untouched, and say nothing at all about a key
+ * it had never heard of. MEASURED on this repo's own CLI before the change:
+ *
+ * ```
+ * $ echo '{"surfaceRootz":[".ai"]}' > .vigilesrc.json && vigiles audit .
+ * (no complaint about the unknown key — exit 0)
+ * ```
+ *
+ * A key the tool does not read is a line the user believes is working. That is
+ * the product's own subject — a passing signal standing in for work nobody did —
+ * happening inside the tool, so the shape is now DECLARED and anything outside
+ * it is named out loud.
+ *
+ * THE TYPE IS DERIVED FROM THIS, not written beside it: `VigilesConfig` is
+ * `z.infer<typeof vigilesConfigSchema>` (see `./types.ts`), so a field cannot
+ * exist in the type and not in the validator, which is how `surfaceRoots` ended
+ * up documented in `docs/cli.md` for a week after it stopped being read.
+ *
+ * DEFAULTS LIVE HERE TOO, and that is what makes the derivation exact. Every key
+ * the loaded config is guaranteed to carry (`rules`, `files`, `ruleMarkers`)
+ * carries a Zod `.default(...)`, and Zod's inferred OUTPUT type for a defaulted
+ * field is non-optional — so `z.infer` reproduces the old
+ * `rules: Required<RulesConfig>` exactly, rather than approximating it. Parsing
+ * `{}` yields byte-for-byte the old `DEFAULT_CONFIG`.
+ *
+ * ⚠️ ZOD COSTS ~45 ms TO IMPORT (measured, Zod 4.6.5), AND IT IS IMPORTED
+ * NORMALLY — `src/core/validate.ts` has a top-level `import`, not a deferred
+ * `require`. The deferral was tried and is recorded there rather than here,
+ * because the reason it was dropped is a property of the two worlds this code
+ * runs in, not of this file. What matters here: the genuinely hot rail — a
+ * compiled hook's decision, `vigiles hook-runtime run-program`, one fresh
+ * process per matching tool call — never loads the verb barrel and therefore
+ * never loads this module (`src/cli.ts` branches first;
+ * `src/hook-runtime-graph.test.ts` fails the day that stops being true). The
+ * rails that DO load the barrel already pay ~316 ms of Node startup and ~85
+ * requires, against which 45 ms is ~13%.
+ */
+import { z } from "zod";
+/** The rule names, for the "did you mean" on an unknown one. */
+export declare const RULE_NAMES: readonly string[];
+/**
+ * ONE harness's entry in {@link vigilesConfigSchema}'s `harnesses`.
+ *
+ * `.strict()` is load-bearing here specifically: the whole reason this key
+ * exists is that a declaration which reaches nothing used to be silent, and
+ * `{"claude-code": {"root": ".ai"}}` (singular, no `s`) reaches nothing.
+ */
+declare const harnessDeclarationSchema: z.ZodObject<{
+    roots: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+}, z.core.$strict>;
+/** The harness keys' value shape, exported so `types.ts` can derive the type. */
+export type HarnessDeclarationShape = z.infer<typeof harnessDeclarationSchema>;
+/**
+ * The whole of `.vigilesrc.json`.
+ *
+ * `.strict()` at the top level is the check that did not exist: an unrecognized
+ * key is now a named error with a suggestion, where it used to be spread into
+ * the config object and never read.
+ */
+export declare const vigilesConfigSchema: z.ZodObject<{
+    ruleMarkers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        headings: "headings";
+        checkboxes: "checkboxes";
+    }>>>;
+    rules: z.ZodPrefault<z.ZodObject<{
+        "spec-refs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "orphan-docs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "duplicate-rules": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "require-instructions-spec": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "require-skill-spec": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        integrity: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        coverage: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
+            linterRules: z.ZodOptional<z.ZodNumber>;
+            scripts: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>], null>, z.ZodTuple<[z.ZodLiteral<"error">, z.ZodObject<{
+            linterRules: z.ZodOptional<z.ZodNumber>;
+            scripts: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>], null>]>>;
+        "untested-skill": z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
+            include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            testExtension: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], null>, z.ZodTuple<[z.ZodLiteral<"error">, z.ZodObject<{
+            include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            testExtension: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], null>]>>;
+        "untested-subagent": z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
+            include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            testExtension: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], null>, z.ZodTuple<[z.ZodLiteral<"error">, z.ZodObject<{
+            include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            testExtension: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], null>]>>;
+        "untested-hook": z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>, z.ZodTuple<[z.ZodLiteral<"warn">, z.ZodObject<{
+            include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            testExtension: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], null>, z.ZodTuple<[z.ZodLiteral<"error">, z.ZodObject<{
+            include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+            testExtension: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], null>]>>;
+        "unmarked-refs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "subagent-tool-contract": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "hook-events": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "subagent-frontmatter": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "mcp-config": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "skill-frontmatter": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "mcp-tool-resolves": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "hook-script-exists": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "prefer-compiled-hooks": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "disallowed-tools-contract": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "description-overlap": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "skill-description-budget": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "frontmatter-valid": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "mcp-hook-target-resolves": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "lethal-trifecta": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "skill-resource-resolves": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "skill-missing-fence": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "plugin-dir-layout": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "delegation-trifecta": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "hook-block-ineffective": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "hook-matcher": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+        "doc-refs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "off" | "warn" | "error">>>;
+    }, z.core.$strict>>;
+    files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    maxRules: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    maxSectionLines: z.ZodOptional<z.ZodNumber>;
+    catalogOnly: z.ZodOptional<z.ZodBoolean>;
+    linters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        rulesDir: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>>;
+    bundles: z.ZodOptional<z.ZodEnum<{
+        root: "root";
+        all: "all";
+    }>>;
+    orphans: z.ZodOptional<z.ZodObject<{
+        include: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+        exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+    }, z.core.$strict>>;
+    exclude: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+    sharedDirs: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+    harnesses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        roots: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<readonly string[], string | string[]>>>;
+    }, z.core.$strict>>>;
+    audit: z.ZodOptional<z.ZodObject<{
+        measure: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    eval: z.ZodOptional<z.ZodObject<{
+        apiVersion: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    nudge: z.ZodOptional<z.ZodLiteral<"dismissed">>;
+    $schema: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * A `.vigilesrc.json` that cannot be honoured as written.
+ *
+ * 🔴 IT HAS ITS OWN CLASS BECAUSE THE READER CATCHES EVERYTHING ELSE. A missing
+ * file, an unreadable one and malformed JSON all mean "use the defaults", which
+ * is right — and a file that IS readable and says something we refuse must not
+ * join them, or the user's declaration vanishes into the defaults and the run
+ * looks clean. A distinct class is what lets the CLI print it as a config error
+ * and a hook rail downgrade it to a warning, from one throw site.
+ */
+export declare class VigilesConfigError extends Error {
+    readonly name = "VigilesConfigError";
+}
+/**
+ * The whole config, AS THE SCHEMA DEFINES IT — `VigilesConfig` is this.
+ *
+ * Exported from here and re-exported (type-only, so no runtime cycle) by
+ * `./types.ts`, which every consumer already imports. The derivation is the
+ * point: a key cannot be in the type and absent from the validator.
+ */
+export type VigilesConfigShape = z.infer<typeof vigilesConfigSchema>;
+/**
+ * The two keys `harnesses` replaced, and the sentence each one gets (#240).
+ *
+ * They are listed here rather than left to `.strict()`'s "Unrecognized key"
+ * because the reader of that message is someone whose config USED to work: they
+ * need the new spelling, not the news that the old one is unknown. `.strict()`
+ * would tell them the truth in the least useful possible way.
+ */
+export declare const REPLACED_KEYS: ReadonlyArray<{
+    readonly key: string;
+    readonly was: string;
+    readonly now: string;
+}>;
+/** The message a config written in the replaced shape gets. */
+export declare function replacedKeyMessage(present: ReadonlyArray<(typeof REPLACED_KEYS)[number]>): string;
+/**
+ * Turn a Zod failure into the lines a human acts on — ONE per real problem.
+ *
+ * 🔴 THE FORMATTER IS THE POINT, because the library's own message is worse than
+ * what it replaced on the two things that matter. Measured on Zod 4.6.5 against
+ * this schema:
+ *
+ * ```
+ * {"rules":{"spec-refs":"errr"}}
+ *   -> invalid_union, EIGHT branch errors: expected "warn" / "error" / false /
+ *      "off" / 0 / 1 / 2 / true — one line per union member, none of them the
+ *      sentence "these are the values this key takes"
+ * {"harnessez":{}}
+ *   -> Unrecognized key: "harnessez"   (names the culprit, suggests nothing)
+ * ```
+ *
+ * The first is CASCADE NOISE: a union failure is one problem, not eight, and
+ * printing the branches makes the schema's internals the user's problem. The
+ * second is the regression we refuse to ship — the line it would replace is
+ * `✗ Unknown harness "claud-code". Known: claude-code, codex.`, which names the
+ * candidates AND the near-miss. So a union collapses to one line listing what
+ * the key accepts, and an unknown key carries the candidate list plus a
+ * distance-bounded "did you mean".
+ */
+export declare function formatConfigIssues(issues: readonly ConfigIssue[]): string[];
+/**
+ * The shape of a Zod issue this formatter reads — structural, not imported.
+ *
+ * Zod's own `$ZodIssue` union is exhaustive over every code the library can
+ * emit, and switching on it would make adding a schema construct a compile
+ * error in a message formatter that has a perfectly good default branch. The
+ * fields below are the ones read; everything else falls through to `message`.
+ */
+export interface ConfigIssue {
+    readonly code?: string;
+    readonly path?: readonly PropertyKey[];
+    readonly message?: string;
+    readonly keys?: readonly string[];
+    readonly expected?: string;
+    readonly values?: readonly unknown[];
+    readonly errors?: ReadonlyArray<readonly ConfigIssue[]>;
+}
+export {};
+//# sourceMappingURL=config-schema.d.ts.map