vigiles 26.0.0 → 26.0.1

package/dist/cli.js

@@ -1283,24 +1283,20 @@ async function checkSpecRefs(excludes, config, silent, dialect) {
     if (!sev)
         return { issues: 0, errors: 0 };
     const found = [];
+    let knownAgents;
     for (const specPath of findSpecs(excludes)) {
         const target = specPath.replace(/\.spec\.ts$/, "");
         if (!(0, node_fs_1.existsSync)(target))
             continue; // never compiled — `compile` reports it
         const spec = await loadSpec(specPath);
-        if (!spec || spec._specType !== "claude")
+        if (!spec)
             continue;
         try {
-            const { errors } = (0, compile_js_1.compileClaude)(spec, {
-                basePath: process.cwd(),
-                specFile: specPath,
-                dialect,
-                maxRules: config?.maxRules,
-                maxTokens: config?.maxTokens,
-                maxSectionLines: config?.maxSectionLines,
-                catalogOnly: config?.catalogOnly,
-                linters: config?.linters,
-            });
+            // Railway is the one type whose validation needs the sibling agent names;
+            // 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 ?? []);
             for (const e of errors)
                 found.push(`${target}: ${e.message} (from ${specPath})`);
         }
@@ -1319,6 +1315,53 @@ async function checkSpecRefs(excludes, config, silent, dialect) {
     }
     return { issues: found.length, errors: sev === "error" ? found.length : 0 };
 }
+/**
+ * The ONE spec-type dispatcher, in the only shape both directions can share:
+ * errors, no writing. `compile` reaches its compilers through the
+ * `compile*ToFile` wrappers (which write and print); `checkSpecRefs` reaches the
+ * SAME compilers through this, because a read must never write.
+ *
+ * Why it exists (#190): `checkSpecRefs` used to call `compileClaude` directly and
+ * skip every other spec type, so a SKILL.md / subagent / railway artifact
+ * committed with a since-deleted reference hashed cleanly against its own header
+ * forever — `lint` green, `compile` red. Measured on this repo:
+ * `examples/SKILL.md.spec.ts` names `skills/enforce-rules-format/SKILL.md`, which
+ * does not exist (the skill lives under `.claude/skills/`), and `lint` reported
+ * `hash valid`.
+ *
+ * A switch rather than a per-type "ref accessor": all four compilers already
+ * return the same `errors: CompileError[]`, so there is nothing to normalize —
+ * 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) {
+    const basePath = process.cwd();
+    switch (spec._specType) {
+        case "claude":
+            return (0, compile_js_1.compileClaude)(spec, {
+                basePath,
+                specFile: specPath,
+                dialect,
+                maxRules: config?.maxRules,
+                maxTokens: config?.maxTokens,
+                maxSectionLines: config?.maxSectionLines,
+                catalogOnly: config?.catalogOnly,
+                linters: config?.linters,
+            }).errors;
+        case "skill":
+            return (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;
+        case "railway":
+            return (0, compile_js_1.compileRailway)(spec, { specFile: specPath, knownAgents }).errors;
+        default:
+            // A `pipeline` spec compiles through its underlying railway, so it has no
+            // artifact of its own to re-derive refs for.
+            return [];
+    }
+}
 /**
  * Write a compiled artifact. Accepts ONLY a {@link StampedMarkdown}, so a body
  * that failed to compile cannot reach the disk — there is no stamp to pass.

package/dist/core/compile.js

@@ -690,7 +690,6 @@ function yamlScalar(value) {
 function renderSkillFrontmatter(spec, profile = "claude-code") {
     const fm = [
         "---",
-        "",
         `name: ${yamlScalar(spec.name)}`,
         `description: ${yamlScalar(spec.description)}`,
     ];
@@ -724,7 +723,7 @@ function renderSkillFrontmatter(spec, profile = "claude-code") {
             fm.push(`disallowed-tools: [${spec.disallowedTools.join(", ")}]`);
         }
     }
-    fm.push("", "---");
+    fm.push("---");
     return fm.join("\n");
 }
 /**
@@ -871,7 +870,15 @@ function compileSkill(spec, options = {}) {
     const warnings = checkInlineCode(sections, spec.maxInlineCodeLines ?? DEFAULT_MAX_INLINE_CODE_LINES);
     const marker = purityMarker(spec.purity);
     const content = renderSkillFrontmatter(spec, profile) +
-        "\n\n" +
+        // ONE newline, not two: `placeIntegrityHeader` puts the stamp AFTER the
+        // frontmatter and supplies its own blank line on each side, so a second one
+        // here becomes two blank lines in the artifact — which `prettier --check`
+        // rejects, and a freshly compiled artifact then cannot pass `npm run check`.
+        // Fixed HERE rather than in the stamper: the hash is computed over this
+        // content (compile.ts `seal`), so trimming inside `placeIntegrityHeader`
+        // would hash one string and write another — measured, it broke integrity on
+        // all three frontmatter-bearing artifacts.
+        "\n" +
         (marker ? marker + "\n\n" : "") +
         sections.trim() +
         "\n";
@@ -913,7 +920,6 @@ function renderAgentFrontmatter(spec) {
     // {@link yamlScalar}.
     const fm = [
         "---",
-        "",
         `name: ${yamlScalar(spec.name)}`,
         `description: ${yamlScalar(spec.description)}`,
     ];
@@ -927,7 +933,7 @@ function renderAgentFrontmatter(spec) {
     if (spec.disallowedTools && spec.disallowedTools.length > 0) {
         fm.push(`disallowedTools: ${spec.disallowedTools.join(", ")}`);
     }
-    fm.push("", "---");
+    fm.push("---");
     return fm.join("\n");
 }
 /**
@@ -1070,7 +1076,15 @@ function compileAgent(spec, options) {
     const warnings = checkInlineCode(body, DEFAULT_MAX_INLINE_CODE_LINES);
     const marker = purityMarker(spec.purity);
     const content = renderAgentFrontmatter(spec) +
-        "\n\n" +
+        // ONE newline, not two: `placeIntegrityHeader` puts the stamp AFTER the
+        // frontmatter and supplies its own blank line on each side, so a second one
+        // here becomes two blank lines in the artifact — which `prettier --check`
+        // rejects, and a freshly compiled artifact then cannot pass `npm run check`.
+        // Fixed HERE rather than in the stamper: the hash is computed over this
+        // content (compile.ts `seal`), so trimming inside `placeIntegrityHeader`
+        // would hash one string and write another — measured, it broke integrity on
+        // all three frontmatter-bearing artifacts.
+        "\n" +
         (marker ? marker + "\n\n" : "") +
         body.trim() +
         "\n";

package/dist/hook.js

@@ -133,8 +133,20 @@ Object.defineProperty(exports, "isStateWrite", { enumerable: true, get: function
 Object.defineProperty(exports, "admissibleWrites", { enumerable: true, get: function () { return hook_state_js_1.admissibleWrites; } });
 Object.defineProperty(exports, "durationSeconds", { enumerable: true, get: function () { return hook_state_js_1.durationSeconds; } });
 Object.defineProperty(exports, "HookStateError", { enumerable: true, get: function () { return hook_state_js_1.HookStateError; } });
-// Operation-normalized leaf extraction — the robust matching primitive a
-// hardened guard is built on (see examples/harness/safe-bash-guard-v2.mjs).
+// Operation-normalized leaf extraction — the primitive `runs()`, `touches()`
+// and `pipesToShell()` match over, so a guard written against the closed
+// vocabulary sees the OPERATION rather than the literal tokens.
+//
+// It is exported because `examples/harness/safe-bash-guard-v2.mjs` needs it —
+// and that need is the finding, not the feature. v2 is an UNRUN experiment (no
+// test executes it) covering three things the vocabulary cannot yet express: a
+// flag with a value (`--index-url`), an env-assignment prefix, and a
+// cross-leaf pipeline fact (`env | curl`). Reaching for this export is how a
+// guard author escapes the closed vocabulary — the thing `checkHookImports`
+// exists to prevent — so treat a new consumer as a request for vocabulary,
+// not as the intended path. Measured 2026-09-03: on the 7 seeds plus every
+// generated spelling (143 cases) v1 and v2 both block 143/143, so v2 is no
+// longer the "hardened" one; see zernie/vigiles#193.
 var bash_effects_js_1 = require("./core/bash-effects.js");
 Object.defineProperty(exports, "leafCommandsNormalized", { enumerable: true, get: function () { return bash_effects_js_1.leafCommandsNormalized; } });
 //# sourceMappingURL=hook.js.map

package/package.json

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