vigiles 30.0.2 → 31.0.0

package/dist/adapter-conformance.js

@@ -14,8 +14,7 @@ exports.assertAdapterLoadsHooks = assertAdapterLoadsHooks;
  */
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const compile_js_1 = require("./core/compile.js");
-const spec_js_1 = require("./core/spec.js");
+const tool_contract_js_1 = require("./core/tool-contract.js");
 const plugin_loader_js_1 = require("./plugin-loader.js");
 const vocabulary_consistency_js_1 = require("./core/vocabulary-consistency.js");
 const event_capability_js_1 = require("./core/event-capability.js");
@@ -190,21 +189,16 @@ function checkAdapterConformance(adapter) {
     catch (e) {
         need(false, `layout.settings ("${adapter.layout.settings.label}") threw on its own output: ${String(e)}`);
     }
-    // Behavioural: the dialect drives the compiler — its own built-in tool must
-    // pass the subagent tool-contract check under this dialect.
+    // Behavioural: the dialect drives the subagent tool-contract check — its own built-in tool
+    // must pass that check under this dialect. This calls the SAME validator `compileAgent` uses
+    // (`verifyToolContract` + `authoringIssues`) rather than `compileAgent` itself: the tool
+    // contract is what this line claims to check, and compiling a whole agent would tie this
+    // synchronous public kit to the compiler's (async) reference validation for nothing.
     const tool = adapter.dialect.builtinAgentTools[0];
     if (tool) {
-        const spec = (0, spec_js_1.experimental_agent)({
-            name: "conformance",
-            description: "conformance probe",
-            tools: [tool],
-            body: "probe",
-        });
-        const r = (0, compile_js_1.compileAgent)(spec, {
-            specFile: "conformance.md.spec.ts",
-            dialect: adapter.dialect,
-        });
-        need(!r.errors.some((e) => e.type === "unknown-tool"), `dialect rejects its own built-in tool "${tool}"`);
+        const issues = (0, tool_contract_js_1.authoringIssues)((0, tool_contract_js_1.verifyToolContract)([tool], adapter.dialect));
+        need(issues.length === 0, `dialect rejects its own built-in tool "${tool}"` +
+            (issues.length ? `: ${issues.map((i) => i.message).join("; ")}` : ""));
     }
     return { ok: failures.length === 0, failures };
 }

package/dist/claude-code.js

@@ -15,6 +15,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSelectionReport = exports.assertNoCollision = exports.measureSelectionMatrix = exports.agent = exports.experimental_skill = exports.experimental_agent = exports.claudeAvailable = exports.parseClaudeRun = exports.buildClaudeArgs = exports.claudeCodeDriver = void 0;
+// 🔴 PUBLIC ENTRY POINT `vigiles/claude-code` — every export here is a promise to users. The default for a
+// symbol is INTERNAL. It is exported only if (a) a NAMED external consumer uses it, or (b) it is
+// a deliberate extension point listed in STABILITY.md (the adapter kit is the example). "Might
+// be useful" is neither. Review point: the diff of `api-surface/vigiles-claude-code.api.md`, which
+// `npm run api:check` fails on.
 /**
  * `vigiles/claude-code` — the Claude Code-specific harness pieces a *different*
  * harness would swap out: the plugin/repo loader (reads real Claude Code plugin

package/dist/cli-main.js

@@ -335,9 +335,9 @@ function compileGeneratorSkillToFile(specPath, source) {
     return false;
 }
 /** Compile a ClaudeSpec → its primary + any additional targets. */
-function compileClaudeToFile(spec, specPath, config, dialect) {
+async function compileClaudeToFile(spec, specPath, config, dialect) {
     const basePath = process.cwd();
-    const { markdown, errors, warnings, linterResults, targets } = (0, compile_js_1.compileClaude)(spec, {
+    const { markdown, errors, warnings, linterResults, targets } = await (0, compile_js_1.compileClaude)(spec, {
         basePath,
         specFile: specPath,
         dialect,
@@ -471,9 +471,9 @@ function formatArtifactSize(markdown) {
     return `${size} · ~${String(kTokens)}k tokens est.`;
 }
 /** Compile a declarative SkillSpec → SKILL.md. */
-function compileSkillToFile(spec, specPath, dialect) {
+async function compileSkillToFile(spec, specPath, dialect) {
     const outputPath = specPath.replace(/\.spec\.ts$/, "");
-    const { artifact, errors, warnings } = (0, compile_js_1.compileSkill)(spec, {
+    const { artifact, errors, warnings } = await (0, compile_js_1.compileSkill)(spec, {
         basePath: process.cwd(),
         specFile: specPath,
         // The SKILL.md frontmatter profile comes from the resolved harness — a Codex
@@ -495,9 +495,9 @@ function compileSkillToFile(spec, specPath, dialect) {
     return false;
 }
 /** Compile a subagent spec → agents/<name>.md (with its result-contract section). */
-function compileAgentToFile(spec, specPath, dialect) {
+async function compileAgentToFile(spec, specPath, dialect) {
     const outputPath = specPath.replace(/\.spec\.ts$/, "");
-    const { artifact, errors, warnings } = (0, compile_js_1.compileAgent)(spec, {
+    const { artifact, errors, warnings } = await (0, compile_js_1.compileAgent)(spec, {
         basePath: process.cwd(),
         specFile: specPath,
         dialect,
@@ -592,7 +592,7 @@ async function compile(specPaths, config, excludes, opts = {}) {
             const specDialect = opts.harnessFlag === undefined
                 ? ((0, adapter_registry_js_1.adapterForInstructionFile)(targetFile)?.dialect ?? dialect)
                 : dialect;
-            if (compileClaudeToFile(spec, specPath, config, specDialect)) {
+            if (await compileClaudeToFile(spec, specPath, config, specDialect)) {
                 writeInstructionMirrors(specPath.replace(/\.spec\.ts$/, ""), declaredHarnesses);
             }
             else {
@@ -608,11 +608,11 @@ async function compile(specPaths, config, excludes, opts = {}) {
             for (const w of (0, skill_harness_js_1.skillFrontmatterDropWarnings)(spec, forHarnesses)) {
                 console.log(`⚠ ${w}`);
             }
-            if (!compileSkillToFile(spec, specPath, dialect))
+            if (!(await compileSkillToFile(spec, specPath, dialect)))
                 allValid = false;
         }
         else if (spec._specType === "agent") {
-            if (!compileAgentToFile(spec, specPath, dialect))
+            if (!(await compileAgentToFile(spec, specPath, dialect)))
                 allValid = false;
         }
         else if (spec._specType === "railway") {
@@ -821,7 +821,7 @@ async function findDuplicateRules(excludes, threshold = 0.3, silent = false, sco
  * Each named file is parsed on demand; there is no project-wide index. Returns
  * the count of broken references.
  */
-function verifyMarkdownSymbols(files, silent) {
+async function verifyMarkdownSymbols(files, silent) {
     if (files.length === 0)
         return 0;
     const cwd = process.cwd();
@@ -835,7 +835,7 @@ function verifyMarkdownSymbols(files, silent) {
         catch {
             continue;
         }
-        const broken = (0, refs_js_1.verifySymbolRefs)(markdown, (0, node_path_1.dirname)((0, node_path_1.resolve)(cwd, f)));
+        const broken = await (0, refs_js_1.verifySymbolRefs)(markdown, (0, node_path_1.dirname)((0, node_path_1.resolve)(cwd, f)));
         if (broken.length === 0)
             continue;
         if (!silent) {
@@ -1361,7 +1361,7 @@ async function checkSpecRefs(excludes, config, silent, dialect) {
             // collected lazily so a repo with no railway spec never pays for the walk.
             if (spec._specType === "railway")
                 knownAgents ??= await collectAgentNames(excludes);
-            const errors = specCompileErrors(spec, specPath, dialect, config, knownAgents ?? []);
+            const errors = await specCompileErrors(spec, specPath, dialect, config, knownAgents ?? []);
             for (const e of errors)
                 found.push(`${target}: ${e.message} (from ${specPath})`);
         }
@@ -1399,11 +1399,11 @@ async function checkSpecRefs(excludes, config, silent, dialect) {
  * only the options differ. Exhaustive over `_specType`, so a FIFTH spec type is
  * a tsc error here instead of a silent skip, which is the failure this closes.
  */
-function specCompileErrors(spec, specPath, dialect, config, knownAgents) {
+async function specCompileErrors(spec, specPath, dialect, config, knownAgents) {
     const basePath = process.cwd();
     switch (spec._specType) {
         case "claude":
-            return (0, compile_js_1.compileClaude)(spec, {
+            return (await (0, compile_js_1.compileClaude)(spec, {
                 basePath,
                 specFile: specPath,
                 dialect,
@@ -1412,13 +1412,11 @@ function specCompileErrors(spec, specPath, dialect, config, knownAgents) {
                 maxSectionLines: config?.maxSectionLines,
                 catalogOnly: config?.catalogOnly,
                 linters: config?.linters,
-            }).errors;
+            })).errors;
         case "skill":
-            return (0, compile_js_1.compileSkill)(spec, { basePath, specFile: specPath, dialect })
-                .errors;
+            return (await (0, compile_js_1.compileSkill)(spec, { basePath, specFile: specPath, dialect })).errors;
         case "agent":
-            return (0, compile_js_1.compileAgent)(spec, { basePath, specFile: specPath, dialect })
-                .errors;
+            return (await (0, compile_js_1.compileAgent)(spec, { basePath, specFile: specPath, dialect })).errors;
         case "railway":
             return (0, compile_js_1.compileRailway)(spec, { specFile: specPath, knownAgents }).errors;
         default:
@@ -1725,7 +1723,7 @@ async function runLint(restArgs, flags, excludes, config) {
         }
     }
     // 9. Verify code-shaped symbol references live (see src/refs.ts).
-    const symbolRefErrors = verifyMarkdownSymbols(files, silent);
+    const symbolRefErrors = await verifyMarkdownSymbols(files, silent);
     // 10. Verify `vigiles:mcp server#tool` marks against live MCP servers
     // (only when a .mcp.json declares them). See src/mcp.ts.
     const mcpRefErrors = await verifyMarkdownMcpRefs(files, silent);
@@ -5648,7 +5646,7 @@ async function handleHookRuntime(kind, restArgs) {
             actionHookCommand();
             return;
         case "refs":
-            refsHookCommand();
+            await refsHookCommand();
             return;
         case "eval-lock-nudge":
             evalLockNudgeHookCommand();
@@ -5797,7 +5795,7 @@ function evalLockNudgeHookCommand() {
  * agent mark its references, at write time, with full context. `vigiles:ignore`
  * opts a prose span out.
  */
-function refsHookCommand() {
+async function refsHookCommand() {
     let raw = "";
     try {
         raw = (0, node_fs_1.readFileSync)(0, "utf-8");
@@ -5830,7 +5828,7 @@ function refsHookCommand() {
     catch {
         return;
     }
-    const issues = (0, refs_js_1.collectRefIssues)(markdown, (0, node_path_1.dirname)((0, node_path_1.resolve)(cwd, file)));
+    const issues = await (0, refs_js_1.collectRefIssues)(markdown, (0, node_path_1.dirname)((0, node_path_1.resolve)(cwd, file)));
     const action = (0, refs_js_1.refsHookAction)(issues.length, severity);
     if (action === "ok")
         return;

package/dist/codex.js

@@ -14,6 +14,11 @@ 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 });
+// 🔴 PUBLIC ENTRY POINT `vigiles/codex` — every export here is a promise to users. The default for a
+// symbol is INTERNAL. It is exported only if (a) a NAMED external consumer uses it, or (b) it is
+// a deliberate extension point listed in STABILITY.md (the adapter kit is the example). "Might
+// be useful" is neither. Review point: the diff of `api-surface/vigiles-codex.api.md`, which
+// `npm run api:check` fails on.
 /**
  * `vigiles/codex` — the OpenAI Codex harness adapter. Sits beside
  * `vigiles/claude-code`: same harness-agnostic `vigiles` testing core, a

package/dist/core/compile.d.ts

@@ -63,7 +63,7 @@ export interface CompileError {
 export declare function validateFileRef(filePath: string, basePath: string): CompileError | null;
 export declare function readPackageScripts(basePath: string): Record<string, string> | null;
 export declare function validateCommandRef(command: string, basePath: string): CompileError | null;
-export declare function validateSymbolRef(file: string, name: string, basePath: string): CompileError | null;
+export declare function validateSymbolRef(file: string, name: string, basePath: string): Promise<CompileError | null>;
 export declare function validateDirRef(dirPath: string, basePath: string): CompileError | null;
 export declare function validateGlobRef(pattern: string, basePath: string): CompileError | null;
 export interface CompileClaudeResult {
@@ -142,7 +142,7 @@ export declare const DEFAULT_MAX_SECTION_CHARS = 15000;
  * Returns the compiled markdown, validation errors, and linter check results.
  * The markdown is generated even if there are errors (with warnings).
  */
-export declare function compileClaude(spec: ClaudeSpec, options?: CompileClaudeOptions): CompileClaudeResult;
+export declare function compileClaude(spec: ClaudeSpec, options?: CompileClaudeOptions): Promise<CompileClaudeResult>;
 export interface CompileSkillResult {
     /**
      * The stamped artifact — present ONLY when `errors` is empty. `null` is what
@@ -163,7 +163,7 @@ export declare function compileSkill(spec: SkillSpec, options?: {
     /** The harness dialect — supplies `skillFrontmatterKeys`. Omitting it emits
      *  every key the compiler can render, so existing callers are unchanged. */
     dialect?: HarnessDialect;
-}): CompileSkillResult;
+}): Promise<CompileSkillResult>;
 export interface CompileAgentResult {
     /**
      * The stamped artifact — present ONLY when `errors` is empty. `null` is what
@@ -186,7 +186,7 @@ export declare function compileAgent(spec: AgentSpec, options: {
     /** The harness dialect to verify the tool contract against (required — the
      *  core defines no default dialect; the adapter/composition root injects it). */
     dialect: HarnessDialect;
-}): CompileAgentResult;
+}): Promise<CompileAgentResult>;
 export interface CompileRailwayOptions {
     /** Names of compiled agents, to resolve `delegate` targets. Skipped if omitted. */
     knownAgents?: readonly string[];
@@ -230,5 +230,5 @@ export interface AdoptResult {
  * Compare a generated file against what the spec would produce.
  * Returns the diff so users can see what was manually changed.
  */
-export declare function adoptDiff(filePath: string, spec: ClaudeSpec | SkillSpec | AgentSpec, basePath: string, dialect: HarnessDialect): AdoptResult;
+export declare function adoptDiff(filePath: string, spec: ClaudeSpec | SkillSpec | AgentSpec, basePath: string, dialect: HarnessDialect): Promise<AdoptResult>;
 //# sourceMappingURL=compile.d.ts.map

package/dist/core/compile.js

@@ -169,7 +169,7 @@ function validateCommandRef(command, basePath) {
     }
     return null;
 }
-function validateSymbolRef(file, name, basePath) {
+async function validateSymbolRef(file, name, basePath) {
     const full = (0, node_path_1.resolve)(basePath, file);
     if (!(0, node_fs_1.existsSync)(full)) {
         return {
@@ -178,7 +178,7 @@ function validateSymbolRef(file, name, basePath) {
             path: file,
         };
     }
-    const support = (0, symbols_js_1.langForFile)(file);
+    const support = await (0, symbols_js_1.langForFile)(file);
     if (support.kind === "unsupported") {
         return {
             type: "stale-ref",
@@ -186,16 +186,16 @@ function validateSymbolRef(file, name, basePath) {
             path: file,
         };
     }
-    if (support.kind === "grammar-missing") {
-        // The language is parseable by this tool; the optional grammar is absent in THIS install.
+    if (support.kind === "grammar-load-failed") {
+        // The language is parseable by this tool; its grammar failed to load in THIS process.
         // 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})`,
+            message: (0, symbols_js_1.notCheckedReason)(support),
             path: file,
         };
     }
-    if (!(0, symbols_js_1.fileDefinesSymbol)(full, name)) {
+    if (!(await (0, symbols_js_1.fileDefinesSymbol)(full, name))) {
         return {
             type: "stale-ref",
             message: `"${name}" is not defined in ${file}`,
@@ -235,18 +235,18 @@ function validateGlobRef(pattern, basePath) {
     }
     return null;
 }
-function validateRefs(fragments, basePath) {
+async function validateRefs(fragments, basePath) {
     const errors = [];
     for (const fragment of fragments) {
         if (typeof fragment !== "string") {
-            errors.push(...validateOneRef(fragment, basePath));
+            errors.push(...(await validateOneRef(fragment, basePath)));
         }
     }
     return errors;
 }
 const wrap = (e) => (e ? [e] : []);
 /** Validate a single non-string fragment (a `Ref` or `EffectRegion`). */
-function validateOneRef(r, basePath) {
+async function validateOneRef(r, basePath) {
     switch (r._ref) {
         case "file":
             return wrap(validateFileRef(r.path, basePath));
@@ -263,7 +263,7 @@ function validateOneRef(r, basePath) {
                 ]
                 : [];
         case "symbol":
-            return wrap(validateSymbolRef(r.file, r.symbol, basePath));
+            return wrap(await validateSymbolRef(r.file, r.symbol, basePath));
         case "dir":
             return wrap(validateDirRef(r.path, basePath));
         case "glob":
@@ -448,7 +448,7 @@ const RESERVED_SECTION_KEYS = new Set([
     "key_files",
     "rules",
 ]);
-function compileSectionsSection(spec, basePath, maxSectionLines) {
+async function compileSectionsSection(spec, basePath, maxSectionLines) {
     if (!spec.sections)
         return { lines: [], errors: [] };
     const lines = [];
@@ -467,7 +467,7 @@ function compileSectionsSection(spec, basePath, maxSectionLines) {
             lines.push(`## ${heading}\n\n${content.trim()}`);
         }
         else {
-            errors.push(...validateRefs(content, basePath));
+            errors.push(...(await validateRefs(content, basePath)));
             const rendered = content.map(renderFragment).join("");
             errors.push(...validateSectionContent(name, rendered, maxSectionLines));
             lines.push(`## ${heading}\n\n${rendered.trim()}`);
@@ -581,7 +581,7 @@ function compileRulesSection(spec, basePath, options) {
 // (no frontmatter), so Codex/OpenCode reuse it unchanged — only the h1 target
 // differs, which already comes from the injected dialect. Nothing here is
 // CC-only, so there is no per-dialect branch to gate.
-function compileClaude(spec, options = {}) {
+async function compileClaude(spec, options = {}) {
     const targets = spec.target ?? options.dialect?.instructionTargets[0] ?? DEFAULT_TARGET;
     const target = Array.isArray(targets) ? targets[0] : targets;
     const basePath = options.basePath ?? process.cwd();
@@ -614,7 +614,7 @@ function compileClaude(spec, options = {}) {
     }
     // Per-spec maxSectionLines takes precedence, then compile options
     const maxSectionLines = spec.maxSectionLines ?? options.maxSectionLines;
-    const prose = compileSectionsSection(spec, basePath, maxSectionLines);
+    const prose = await compileSectionsSection(spec, basePath, maxSectionLines);
     const keyFiles = compileKeyFilesSection(spec, basePath);
     const commands = compileCommandsSection(spec, basePath);
     const rules = compileRulesSection(spec, basePath, options);
@@ -902,7 +902,7 @@ function checkInlineCode(markdown, max) {
 /**
  * Compile a SkillSpec into SKILL.md markdown with YAML frontmatter.
  */
-function compileSkill(spec, options = {}) {
+async function compileSkill(spec, options = {}) {
     // 🔴 NORMALISE FIRST, before anything reads the spec. `compileSkill` accepts a
     // `SkillSpec` STRUCTURALLY, so a caller can hand us `{ _specType: "skill", …,
     // result: cmd(…) }` without ever touching `experimental_skill()`. Both readers
@@ -931,7 +931,7 @@ function compileSkill(spec, options = {}) {
             });
         }
     }
-    errors.push(...validateRefs(collectSkillRefs(spec), basePath));
+    errors.push(...(await validateRefs(collectSkillRefs(spec), basePath)));
     // A typed `output` Result contract is valid ONLY for a forked skill: an inline
     // skill has no call→return boundary, so a typed outcome there is a category
     // error (see research/spec-syntax-and-railway-scope.md). Enforce it at compile.
@@ -1063,7 +1063,7 @@ function purityMarker(purity) {
     return `<!-- vigiles:purity:${level} -->`;
 }
 /** Render the subagent's named `##` system-prompt sections (verified like CLAUDE.md). */
-function renderAgentSections(sections, basePath) {
+async function renderAgentSections(sections, basePath) {
     const lines = [];
     const errors = [];
     for (const [name, content] of Object.entries(sections)) {
@@ -1079,7 +1079,7 @@ function renderAgentSections(sections, basePath) {
             lines.push(`## ${heading}\n\n${content.trim()}`);
         }
         else {
-            errors.push(...validateRefs(content, basePath));
+            errors.push(...(await validateRefs(content, basePath)));
             const rendered = content.map(renderFragment).join("");
             errors.push(...validateSectionContent(name, rendered));
             lines.push(`## ${heading}\n\n${rendered.trim()}`);
@@ -1134,7 +1134,7 @@ function renderAgentRules(rules) {
  * Verifies the tool contract and the body's references; the marks the body
  * carries (`vigiles:symbol`, file/cmd refs) are the same ones `lint` re-checks.
  */
-function compileAgent(spec, options) {
+async function compileAgent(spec, options) {
     const basePath = options.basePath ?? process.cwd();
     const specFile = options.specFile ?? "agent.md.spec.ts";
     const dialect = options.dialect;
@@ -1169,13 +1169,13 @@ function compileAgent(spec, options) {
         }
     }
     if (Array.isArray(spec.body)) {
-        errors.push(...validateRefs(spec.body, basePath));
+        errors.push(...(await validateRefs(spec.body, basePath)));
     }
     const sections = [];
     if (spec.body !== undefined)
         sections.push(renderBody(spec.body).trim());
     if (spec.sections) {
-        const result = renderAgentSections(spec.sections, basePath);
+        const result = await renderAgentSections(spec.sections, basePath);
         sections.push(...result.lines);
         errors.push(...result.errors);
     }
@@ -1287,7 +1287,7 @@ function checkFileHash(filePath) {
  * Compare a generated file against what the spec would produce.
  * Returns the diff so users can see what was manually changed.
  */
-function adoptDiff(filePath, spec, basePath, dialect) {
+async function adoptDiff(filePath, spec, basePath, dialect) {
     const fullPath = (0, node_path_1.resolve)(basePath, filePath);
     const currentContent = (0, node_fs_1.existsSync)(fullPath)
         ? (0, node_fs_1.readFileSync)(fullPath, "utf-8")
@@ -1296,7 +1296,7 @@ function adoptDiff(filePath, spec, basePath, dialect) {
     // Compile the spec to get what it WOULD produce
     let compiledContent = null;
     if (spec._specType === "claude") {
-        const { markdown } = compileClaude(spec, {
+        const { markdown } = await compileClaude(spec, {
             basePath,
             specFile: filePath,
             dialect,
@@ -1304,11 +1304,14 @@ function adoptDiff(filePath, spec, basePath, dialect) {
         compiledContent = markdown;
     }
     else if (spec._specType === "skill") {
-        const { markdown } = compileSkill(spec, { basePath, specFile: filePath });
+        const { markdown } = await compileSkill(spec, {
+            basePath,
+            specFile: filePath,
+        });
         compiledContent = markdown;
     }
     else if (spec._specType === "agent") {
-        const { markdown } = compileAgent(spec, {
+        const { markdown } = await compileAgent(spec, {
             basePath,
             specFile: filePath,
             dialect,

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

@@ -69,20 +69,20 @@ export declare const vigilesConfigSchema: z.ZodObject<{
         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<{
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        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 | "warn" | "error" | "off">>>;
+        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 | "warn" | "error" | "off">>, 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<{
+        "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 | "warn" | "error" | "off">>, 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>;
@@ -91,7 +91,7 @@ export declare const vigilesConfigSchema: z.ZodObject<{
             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<{
+        "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 | "warn" | "error" | "off">>, 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>;
@@ -100,7 +100,7 @@ export declare const vigilesConfigSchema: z.ZodObject<{
             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<{
+        "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 | "warn" | "error" | "off">>, 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>;
@@ -109,28 +109,28 @@ export declare const vigilesConfigSchema: z.ZodObject<{
             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">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
+        "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 | "warn" | "error" | "off">>>;
     }, z.core.$strict>>;
     files: z.ZodDefault<z.ZodArray<z.ZodString>>;
     maxRules: z.ZodOptional<z.ZodNumber>;

package/dist/core/refs.d.ts

@@ -26,7 +26,7 @@ export declare function symbolRefs(markdown: string): SymbolRef[];
  * file must exist and define the named symbol. `basePath` is the directory the
  * paths resolve against (the instruction file's own directory).
  */
-export declare function verifySymbolRefs(markdown: string, basePath: string): SymbolRefError[];
+export declare function verifySymbolRefs(markdown: string, basePath: string): Promise<SymbolRefError[]>;
 /**
  * Whether a span is a **linter-rule reference** that ought to be marked
  * (`enforce()` / inline `<!-- vigiles:enforce -->`) so the lint can verify the
@@ -50,7 +50,7 @@ export declare function unmarkedCodeRefs(markdown: string): Span[];
  * code-shaped span that ought to be a mark. The shared detector behind both the
  * `vigiles refs` CLI and the PostToolUse refs-hook.
  */
-export declare function collectRefIssues(markdown: string, basePath: string): string[];
+export declare function collectRefIssues(markdown: string, basePath: string): Promise<string[]>;
 /** What the refs-hook should do given the issue count and configured severity. */
 export type RefsHookAction = "ok" | "nudge" | "block";
 /**