vigiles 30.0.2 → 31.0.1

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/coverage.d.ts

@@ -8,6 +8,7 @@
  * Configurable thresholds in .vigilesrc.json trigger warnings or errors when
  * coverage drops below the minimum.
  */
+import { type GlobIgnore } from "./glob-ignore.js";
 import type { CoverageThresholds } from "./types.js";
 import type { ClaudeSpec } from "./spec.js";
 export interface CoverageMetric {
@@ -35,11 +36,11 @@ export declare function readNpmScripts(basePath: string): string[];
  * Collect commands documented in specs by loading spec source files directly.
  * Reads the structured `commands` field — no markdown parsing.
  */
-export declare function collectDocumentedCommands(basePath: string, specs: ClaudeSpec[] | undefined, ignore: readonly string[]): Set<string>;
+export declare function collectDocumentedCommands(basePath: string, specs: ClaudeSpec[] | undefined, ignore: GlobIgnore): Set<string>;
 /**
  * Compute script coverage: what % of npm scripts are documented in specs.
  */
-export declare function computeScriptCoverage(basePath: string, threshold: number | undefined, specs: ClaudeSpec[] | undefined, ignore: readonly string[]): CoverageMetric;
+export declare function computeScriptCoverage(basePath: string, threshold: number | undefined, specs: ClaudeSpec[] | undefined, ignore: GlobIgnore): CoverageMetric;
 /**
  * Compute linter rule coverage from pre-computed totals.
  * The actual linter scanning is done by the existing discover() in cli.ts.
@@ -48,7 +49,7 @@ export declare function computeLinterRuleCoverage(enabled: number, documented: n
 /**
  * Check all coverage metrics against thresholds.
  */
-export declare function checkCoverage(basePath: string, thresholds: CoverageThresholds, linterEnabled: number, linterDocumented: number, specs: ClaudeSpec[] | undefined, ignore: readonly string[]): CoverageReport;
+export declare function checkCoverage(basePath: string, thresholds: CoverageThresholds, linterEnabled: number, linterDocumented: number, specs: ClaudeSpec[] | undefined, ignore: GlobIgnore): CoverageReport;
 /**
  * Format coverage report as human-readable text.
  */

package/dist/core/coverage.js

@@ -20,6 +20,7 @@ const node_fs_1 = require("node:fs");
 const integrity_js_1 = require("./integrity.js");
 const node_path_1 = require("node:path");
 const glob_1 = require("glob");
+const glob_ignore_js_1 = require("./glob-ignore.js");
 const compile_js_1 = require("./compile.js");
 // ---------------------------------------------------------------------------
 // Script coverage
@@ -50,12 +51,12 @@ function collectDocumentedCommands(basePath, specs, ignore) {
     // Fallback: scan compiled markdown for spec file references, then
     // load the compiled JS spec from dist/. If that fails, try to
     // extract commands from the compiled output (last resort).
-    // `ignore` is the repo's ExcludeSet string face (src/exclude.ts): the floor
-    // plus `.vigilesrc.json#exclude`, required so this fallback cannot walk a
+    // `ignore` is the repo's `ExcludeSet.globIgnore` (src/exclude.ts, correct
+    // from any cwd) or patterns relative to `basePath`, required so this fallback cannot walk a
     // vendored corpus the repo excluded (#192). The CLI always passes `specs`,
     // so this branch is reached by the library path and tests only.
     const mdFiles = (0, glob_1.globSync)("**/*.md", {
-        ignore: [...ignore],
+        ignore: (0, glob_ignore_js_1.withIgnored)([], ignore),
         cwd: basePath,
     });
     for (const mdFile of mdFiles) {

package/dist/core/doc-refs.d.ts

@@ -17,6 +17,7 @@
  * in markdown is explicitly out of scope — use eslint-plugin-markdown or
  * twoslash for that.
  */
+import { type GlobIgnore } from "./glob-ignore.js";
 export type DocRefKind = "enforce" | "file" | "cmd" | "ref";
 export interface DocRef {
     readonly file: string;
@@ -40,7 +41,8 @@ export interface DocRefReport {
 }
 export interface FindDocRefsOptions {
     readonly basePath?: string;
-    readonly ignore?: readonly string[];
+    /** The repo exclude (`ExcludeSet.globIgnore`), or patterns relative to `basePath`. */
+    readonly ignore?: GlobIgnore;
 }
 interface ExtractResult {
     refs: DocRef[];

package/dist/core/doc-refs.js

@@ -29,6 +29,7 @@ const node_fs_1 = require("node:fs");
 const typescript_1 = __importDefault(require("typescript"));
 const node_path_1 = require("node:path");
 const glob_1 = require("glob");
+const glob_ignore_js_1 = require("./glob-ignore.js");
 const linters_js_1 = require("./linters.js");
 const compile_js_1 = require("./compile.js");
 // ---------------------------------------------------------------------------
@@ -239,7 +240,7 @@ function validateRefs(refs, basePath) {
  */
 function findDocRefs(options = {}) {
     const basePath = options.basePath ?? process.cwd();
-    const ignore = [...DEFAULT_IGNORE, ...(options.ignore ?? [])];
+    const ignore = (0, glob_ignore_js_1.withIgnored)(DEFAULT_IGNORE, options.ignore);
     const files = (0, glob_1.globSync)("**/*.md", { cwd: basePath, ignore });
     const allRefs = [];
     let filesIgnored = 0;

package/dist/core/frame.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The frame of a path — WHICH DIRECTORY it is relative to — named by its TYPE
+ * rather than by a comment (#281).
+ *
+ * 🔴 WHY THIS EXISTS. Every path the CLI handled was a bare `string`, so a path
+ * relative to a nested bundle, one relative to the repository and an absolute one
+ * were the same type, and nothing stopped a caller from printing the wrong one.
+ * `overBundles` handed each check ONE `root: string` that had to be the discovery
+ * base, the base of the config's globs AND the frame of every printed path at
+ * once. Under `bundles: "all"` that root was the nested bundle, so `include`
+ * resolved from the wrong directory and `::warning file=skills/x/SKILL.md` named a
+ * file that did not exist from where the command ran — while a root-bundle skill
+ * of the same name made the annotation land on the WRONG real file, which looks
+ * like success.
+ *
+ * Three frames, two of them branded:
+ *   - {@link RepoPath} — relative to {@link Frame.root}, the directory whose
+ *     `.vigilesrc.json` governs the run. Every printed or annotated path.
+ *   - {@link BundlePath} — relative to one {@link Bundle}'s own directory. What a
+ *     per-bundle scan reports.
+ *   - an absolute path — a plain `string`, the only thing the filesystem takes.
+ *
+ * The brand is `Opaque` from `ts-essentials` (a `unique symbol` key, so no object
+ * literal can forge it), imported as a TYPE ONLY: nothing of it survives the
+ * build. It must not reach a public `.d.ts` either — this module is internal and
+ * the API report (`api-surface/*.api.md`) is the gate that would show a leak.
+ *
+ * 🔴 THE ONE CONVERSION POINT. A `RepoPath` is minted here and nowhere else:
+ * {@link Frame.repo} from an absolute path, {@link Bundle.path} from a
+ * `BundlePath`. A cast to `RepoPath` outside this file is refused by ESLint
+ * (`no-restricted-syntax` in `eslint.config.mjs`), so "where did this path get its
+ * frame" always has the answer "in frame.ts".
+ *
+ * WHAT IS UNREPRESENTABLE AND WHAT IS ONLY DETECTABLE. The CLI's output boundary
+ * (`ghAnnotate`, the per-bundle check context) takes `RepoPath`, so handing it a
+ * bundle-relative or absolute string is a tsc error. Upstream of that, scan-core
+ * keeps reporting plain bundle-relative strings, because its browser twin
+ * (`scan-files.ts`) shares those shapes and has no filesystem to have a frame
+ * over. {@link Bundle.scanned} is the seam where such a string gets its frame;
+ * a relative string that is secretly repo-relative still passes it, and that
+ * residue is caught by tests, not by the compiler.
+ *
+ * NODE-FREE: path ops come from `../posix-path.js`, and the caller supplies the
+ * working directory, so this module has no process state of its own.
+ */
+import type { Opaque } from "ts-essentials";
+/** A `/`-separated path relative to {@link Frame.root}. `.` is the root itself. */
+export type RepoPath = Opaque<string, "RepoPath">;
+/** A `/`-separated path relative to one {@link Bundle}'s own directory. */
+export type BundlePath = Opaque<string, "BundlePath">;
+/** One scored directory: the lint target itself, or a nested plugin bundle. */
+export interface Bundle {
+    /** Absolute directory of the bundle. */
+    readonly abs: string;
+    /** Where the bundle sits, from the frame root (`.` when it IS the root). */
+    readonly at: RepoPath;
+    /** A path this bundle's scan reported, re-expressed from the frame root. */
+    path(p: BundlePath): RepoPath;
+    /**
+     * The seam for scan-core's plain strings, which are bundle-relative by
+     * contract (see the header). An ABSOLUTE string is accepted too and converted
+     * directly — `hook-block-ineffective` reports its script that way.
+     */
+    scanned(p: string): RepoPath;
+}
+/** The single owner of "relative to which directory", built once per command. */
+export interface Frame {
+    /** Absolute directory every {@link RepoPath} is relative to. */
+    readonly root: string;
+    /** The one conversion from an absolute path. Throws on a relative input. */
+    repo(abs: string): RepoPath;
+    /** Describe the bundle at an absolute directory, in this frame. */
+    bundle(abs: string): Bundle;
+}
+/**
+ * The frame for a command run from `cwd` against `target` (absolute).
+ *
+ * The root is `cwd` — where `loadConfig()` read `.vigilesrc.json` (it does not
+ * walk up; measured 2026-09-23) — UNLESS the target lies outside it. A foreign
+ * target (`vigiles lint ../other`) is somebody else's repository, and its paths
+ * mean something from ITS root; relative to `cwd` they would all start with
+ * `../`, and a foreign lint must never let the caller's own files satisfy the
+ * target's `sharedDirs` references. That exception was `sharedDirsRootFor` in
+ * the CLI, applied to `sharedDirs` alone; it is owned here now, so `include`,
+ * `exclude`, `sharedDirs` and every printed path agree on one root.
+ */
+export declare function frameFor(cwd: string, target: string): Frame;
+/** The frame rooted at an absolute directory. */
+export declare function frameAt(root: string): Frame;
+//# sourceMappingURL=frame.d.ts.map