vigiles 38.2.0 → 39.0.0

package/dist/core/compile.js

@@ -15,6 +15,7 @@ exports.validateCommandRef = validateCommandRef;
 exports.validateSymbolRef = validateSymbolRef;
 exports.validateDirRef = validateDirRef;
 exports.validateGlobRef = validateGlobRef;
+exports.unverifiedAdvice = unverifiedAdvice;
 exports.compileClaude = compileClaude;
 exports.compileSkill = compileSkill;
 exports.compileAgent = compileAgent;
@@ -36,7 +37,9 @@ const markdown_js_1 = require("./markdown.js");
 const symbols_js_1 = require("./symbols.js");
 const skill_normalize_js_1 = require("./skill-normalize.js");
 const keyfiles_js_1 = require("./keyfiles.js");
+const frame_js_1 = require("./frame.js");
 const linters_js_1 = require("./linters.js");
+const enforce_marker_js_1 = require("./enforce-marker.js");
 const tool_contract_js_1 = require("./tool-contract.js");
 const effects_js_1 = require("./effects.js");
 const instruction_remedies_js_1 = require("./instruction-remedies.js");
@@ -274,7 +277,18 @@ async function validateOneRef(r, basePath) {
             return validateRefs(r.body, basePath);
     }
 }
-function renderFragment(fragment) {
+/** The repo-relative path a spec compiles to: the spec's own name without `.spec.ts`. */
+function compiledPathOf(specFile) {
+    return specFile.endsWith(".spec.ts")
+        ? specFile.slice(0, -".spec.ts".length)
+        : specFile;
+}
+/**
+ * Render one fragment into the compiled file at `out` (repo-relative). A link
+ * resolves from the file it is written into, so every path rendered as a link
+ * goes through {@link linkFrom}.
+ */
+function renderFragment(fragment, out) {
     if (typeof fragment === "string")
         return fragment;
     switch (fragment._ref) {
@@ -283,7 +297,7 @@ function renderFragment(fragment) {
         case "cmd":
             return `\`${fragment.command}\``;
         case "skill":
-            return `[${(0, node_path_1.basename)((0, node_path_1.dirname)(fragment.path))}](${fragment.path})`;
+            return `[${(0, node_path_1.basename)((0, node_path_1.dirname)(fragment.path))}](${(0, frame_js_1.linkFrom)(out, fragment.path)})`;
         case "symbol":
             return `\`vigiles:symbol ${fragment.file}#${fragment.symbol}\``;
         case "dir":
@@ -291,20 +305,61 @@ function renderFragment(fragment) {
         case "glob":
             return `\`${fragment.pattern}\``;
         case "effect": {
-            const inner = fragment.body.map(renderFragment).join("").trim();
+            const inner = renderBody(fragment.body, out).trim();
             return `\n<!-- vigiles:effect -->\n\n${inner}\n\n<!-- /vigiles:effect -->\n`;
         }
         default:
             return (0, hash_js_1.assertNever)(fragment);
     }
 }
-// ---------------------------------------------------------------------------
-// Compile CLAUDE.md spec → markdown
-// ---------------------------------------------------------------------------
-/** `[Details](path#anchor)` for a rule's long text. */
-function detailsLink(details) {
+/** The verdict a linter check result supports. */
+function verdictFromResult(result) {
+    if (!result.exists)
+        return { kind: "unverified", reason: "not-found" };
+    switch (result.enabled) {
+        case "enabled":
+            return { kind: "verified" };
+        case "disabled":
+            return { kind: "unverified", reason: "disabled" };
+        case "unconfigured":
+            return { kind: "unverified", reason: "not-configured" };
+        case "unknown":
+            return { kind: "unverified", reason: "enabled-unknown" };
+        default:
+            return (0, hash_js_1.assertNever)(result.enabled);
+    }
+}
+/**
+ * The sentence the compile prints for an unverified reference: what happened
+ * and the one thing that turns it into "Enforced by".
+ */
+function unverifiedAdvice(ref, reason) {
+    const linter = (0, linters_js_1.extractLinterName)(ref);
+    switch (reason) {
+        case "verify-false":
+            return `${ref}: not checked (\`verify: false\`). Remove the option once the rule resolves, so a typo or a deleted rule fails the compile.`;
+        case "verification-off":
+            return `${ref}: not checked (\`verifyLinters: false\`).`;
+        case "linter-off":
+            return `${ref}: not checked (verification is off for ${linter}).`;
+        case "config-not-read":
+            return `${ref}: the rule exists; catalog-only mode did not read whether your config turns it on.`;
+        case "not-configured":
+            return `${ref}: the rule exists but no block of your ${linter} config sets it, so it runs nowhere. Set it in the config, or make this a guidance() rule.`;
+        case "enabled-unknown":
+            return `${ref}: the rule exists; vigiles could not read whether your ${linter} config turns it on.`;
+        case "not-found":
+            return `${ref}: the rule was not found.`;
+        case "disabled":
+            return `${ref}: the rule is turned off in your ${linter} config.`;
+        default:
+            return (0, hash_js_1.assertNever)(reason);
+    }
+}
+/** `[Details](path#anchor)` for a rule's long text, linked from `out`. */
+function detailsLink(details, out) {
     const anchor = details.anchor === undefined ? "" : `#${details.anchor}`;
-    return `[Details](${details.file.path}${anchor})`;
+    return `[Details](${(0, frame_js_1.linkFrom)(out, details.file.path)}${anchor})`;
 }
 /**
  * The first sentence of `text`: up to the first `.`, `!` or `?` that closes a
@@ -319,8 +374,8 @@ function firstSentence(text) {
     return m ? m[0] : text.trim();
 }
 /** The `**Why:**` line(s) of an enforce rule under its render policy. */
-function enforceWhy(rule) {
-    const link = rule.details ? ` ${detailsLink(rule.details)}` : "";
+function enforceWhy(rule, out) {
+    const link = rule.details ? ` ${detailsLink(rule.details, out)}` : "";
     const render = rule.render ?? "full";
     switch (render) {
         case "full":
@@ -328,25 +383,29 @@ function enforceWhy(rule) {
         case "line":
             return [`**Why:** ${firstSentence(rule.why)}${link}`];
         case "id":
-            return rule.details ? [detailsLink(rule.details)] : [];
+            return rule.details ? [detailsLink(rule.details, out)] : [];
         default:
             return (0, hash_js_1.assertNever)(render);
     }
 }
-function compileRule(id, rule) {
+function compileRule(id, rule, out, verdict) {
     const title = id
         .replace(/[-_]/g, " ")
         .replace(/\b\w/g, (c) => c.toUpperCase());
     switch (rule._kind) {
-        case "enforce":
+        case "enforce": {
+            // "Enforced by" only for a VERIFIED reference (#351); no verdict = not
+            // verified, so the default cannot print the promise by omission.
+            const marker = verdict?.kind === "verified" ? enforce_marker_js_1.ENFORCED_MARKER : enforce_marker_js_1.CLAIMED_MARKER;
             return [
                 `### ${title}`,
                 "",
-                `**Enforced by:** \`${rule.linterRule}\``,
-                ...enforceWhy(rule),
+                `${marker} \`${rule.linterRule}\``,
+                ...enforceWhy(rule, out),
             ].join("\n");
+        }
         case "guidance": {
-            const link = rule.details ? ` ${detailsLink(rule.details)}` : "";
+            const link = rule.details ? ` ${detailsLink(rule.details, out)}` : "";
             return [
                 `### ${title}`,
                 "",
@@ -540,10 +599,22 @@ const RESERVED_SECTION_KEYS = new Set([
     "key_files",
     "rules",
 ]);
-async function compileSectionsSection(spec, basePath, maxSectionLines) {
+/**
+ * The prose sections as they read in the file at `out` (repo-relative): a
+ * fragment's links resolve from that file's directory, so each target of a
+ * multi-target spec renders its own.
+ */
+function renderSections(spec, out) {
+    return Object.entries(spec.sections ?? {}).map(([name, content]) => {
+        const heading = name.charAt(0).toUpperCase() + name.slice(1);
+        const text = typeof content === "string" ? content : renderBody(content, out);
+        return `## ${heading}\n\n${text.trim()}`;
+    });
+}
+/** The prose sections' errors, measured on their rendering at `out`. */
+async function compileSectionsSection(spec, basePath, out, maxSectionLines) {
     if (!spec.sections)
-        return { lines: [], errors: [] };
-    const lines = [];
+        return [];
     const errors = [];
     for (const [name, content] of Object.entries(spec.sections)) {
         // #4: reject reserved section keys that clash with structured fields
@@ -553,19 +624,16 @@ async function compileSectionsSection(spec, basePath, maxSectionLines) {
                 message: `Section key "${name}" is reserved — use the dedicated \`${name}\` field on the spec instead.`,
             });
         }
-        const heading = name.charAt(0).toUpperCase() + name.slice(1);
         if (typeof content === "string") {
             errors.push(...validateSectionContent(name, content, maxSectionLines));
-            lines.push(`## ${heading}\n\n${content.trim()}`);
         }
         else {
             errors.push(...(await validateRefs(content, basePath)));
-            const rendered = content.map(renderFragment).join("");
+            const rendered = renderBody(content, out);
             errors.push(...validateSectionContent(name, rendered, maxSectionLines));
-            lines.push(`## ${heading}\n\n${rendered.trim()}`);
         }
     }
-    return { lines, errors };
+    return errors;
 }
 function compileKeyFilesSection(spec, basePath) {
     // eslint-disable-next-line @typescript-eslint/no-deprecated -- keyFiles is deprecated, not removed: it still compiles until the next major
@@ -602,21 +670,21 @@ function compileCommandsSection(spec, basePath) {
     return { lines: [lines.join("\n")], errors };
 }
 /**
- * Determine if a rule should be verified, checking three levels:
+ * Why a rule is NOT verified at all, checking three levels, or null to verify:
  * 1. Per-rule: enforce("...", "...", { verify: false })
  * 2. Global: options.verifyLinters === false
  * 3. Per-linter: options.linterModes[linterName] === false
  */
-function shouldVerifyRule(rule, options) {
+function skipVerificationReason(rule, options) {
     if (!rule.verify)
-        return false;
+        return "verify-false";
     if (options.verifyLinters === false)
-        return false;
+        return "verification-off";
     const linterName = (0, linters_js_1.extractLinterName)(rule.linterRule);
     const linterMode = options.linterModes?.[linterName];
     if (linterMode === false)
-        return false;
-    return true;
+        return "linter-off";
+    return null;
 }
 /**
  * A rule's `details` must land somewhere: the file exists (the same check as
@@ -641,58 +709,123 @@ function validateRuleDetails(details, basePath) {
         },
     ];
 }
+/** The compile error a checked reference earns, if any. */
+function enforceError(ref, result) {
+    if (!result.exists) {
+        return {
+            type: "invalid-rule",
+            message: result.error ?? `Rule "${ref}" not found in ${result.linter}`,
+            path: ref,
+        };
+    }
+    if (result.enabled === "disabled") {
+        return {
+            type: "invalid-rule",
+            message: `Rule "${result.rule}" exists but is disabled in ${result.linter} config`,
+            path: ref,
+        };
+    }
+    return undefined;
+}
+/** Verify one `enforce()` reference: its verdict, check result and any error. */
+function verifyEnforce(rule, basePath, options) {
+    const skipped = skipVerificationReason(rule, options);
+    if (skipped !== null) {
+        return { verdict: { kind: "unverified", reason: skipped } };
+    }
+    const linterMode = options.linterModes?.[(0, linters_js_1.extractLinterName)(rule.linterRule)];
+    const catalogOnly = options.catalogOnly === true || linterMode === "catalog-only";
+    const result = (0, linters_js_1.checkLinterRule)(rule.linterRule, basePath, {
+        catalogOnly,
+        linters: options.linters,
+    });
+    const verdict = verdictFromResult(result);
+    // catalog-only never reads the config, so "unknown" there has a known cause.
+    const explained = catalogOnly &&
+        verdict.kind === "unverified" &&
+        verdict.reason === "enabled-unknown"
+        ? { kind: "unverified", reason: "config-not-read" }
+        : verdict;
+    return {
+        verdict: explained,
+        result,
+        error: enforceError(rule.linterRule, result),
+    };
+}
 function compileRulesSection(spec, basePath, options) {
     const ruleEntries = Object.entries(spec.rules);
     if (ruleEntries.length === 0) {
-        return { lines: [], errors: [], linterResults: [] };
-    }
-    const ruleLines = ["## Rules"];
-    const errors = [];
-    const linterResults = [];
-    for (const [id, rule] of ruleEntries) {
-        ruleLines.push("");
-        ruleLines.push(compileRule(id, rule));
-        if (rule._kind === "enforce") {
-            const shouldVerify = shouldVerifyRule(rule, options);
-            if (!shouldVerify)
-                continue;
-            const linterName = (0, linters_js_1.extractLinterName)(rule.linterRule);
-            const linterMode = options.linterModes?.[linterName];
-            const catalogOnly = options.catalogOnly || linterMode === "catalog-only";
-            const result = (0, linters_js_1.checkLinterRule)(rule.linterRule, basePath, {
-                catalogOnly,
-                linters: options.linters,
-            });
-            linterResults.push(result);
-            if (!result.exists) {
-                errors.push({
-                    type: "invalid-rule",
-                    message: result.error ??
-                        `Rule "${rule.linterRule}" not found in ${result.linter}`,
-                    path: rule.linterRule,
-                });
-            }
-            else if (result.enabled === "disabled") {
-                errors.push({
-                    type: "invalid-rule",
-                    message: `Rule "${result.rule}" exists but is disabled in ${result.linter} config`,
-                    path: rule.linterRule,
-                });
-            }
-        }
+        return {
+            render: () => [],
+            errors: [],
+            linterResults: [],
+            enforceVerdicts: [],
+        };
     }
-    const detailsErrors = ruleEntries.flatMap(([, rule]) => rule._kind !== "guard" && rule.details
-        ? validateRuleDetails(rule.details, basePath)
-        : []);
+    // Verify FIRST, render second: the marker an `enforce()` gets is the
+    // verdict's, so rendering cannot run ahead of verification (#351). Verified
+    // once; rendered once per output file, since links depend on where it sits.
+    const verified = ruleEntries.map(([id, rule]) => {
+        if (rule._kind !== "enforce")
+            return { id, rule };
+        const check = verifyEnforce(rule, basePath, options);
+        return { id, rule, check: { ref: rule.linterRule, ...check } };
+    });
+    const checks = verified.flatMap((r) => (r.check ? [r.check] : []));
     return {
-        lines: [ruleLines.join("\n")],
-        errors: [...errors, ...detailsErrors],
-        linterResults,
+        render: (out) => [
+            [
+                "## Rules",
+                ...verified.flatMap((r) => [
+                    "",
+                    compileRule(r.id, r.rule, out, r.check?.verdict),
+                ]),
+            ].join("\n"),
+        ],
+        errors: [
+            ...checks.flatMap((c) => (c.error ? [c.error] : [])),
+            ...ruleEntries.flatMap(([, rule]) => rule._kind !== "guard" && rule.details
+                ? validateRuleDetails(rule.details, basePath)
+                : []),
+        ],
+        linterResults: checks.flatMap((c) => (c.result ? [c.result] : [])),
+        enforceVerdicts: checks.map((c) => ({ ref: c.ref, verdict: c.verdict })),
     };
 }
 // ---------------------------------------------------------------------------
 // compileClaude
 // ---------------------------------------------------------------------------
+/** The spec must be named after its primary target: `<target>.spec.ts`. */
+function specNameErrors(specFile, target) {
+    if (!specFile.endsWith(".spec.ts")) {
+        return [
+            {
+                type: "spec-name-mismatch",
+                message: `Spec file "${specFile}" must end with .spec.ts`,
+            },
+        ];
+    }
+    if ((0, node_path_1.basename)(specFile, ".spec.ts") === target)
+        return [];
+    return [
+        {
+            type: "spec-name-mismatch",
+            message: `Spec file "${specFile}" doesn't match target "${target}". Expected "${target}.spec.ts".`,
+        },
+    ];
+}
+/** More rules than `maxRules` allows is an error. */
+function ruleCountErrors(spec, maxRules) {
+    const ruleCount = Object.keys(spec.rules).length;
+    if (!maxRules || ruleCount <= maxRules)
+        return [];
+    return [
+        {
+            type: "invalid-rule",
+            message: `${String(ruleCount)} rules exceeds maxRules limit of ${String(maxRules)}. Split into subdirectory specs.`,
+        },
+    ];
+}
 /**
  * Compile a ClaudeSpec into markdown.
  *
@@ -705,46 +838,33 @@ 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.
-async 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();
+    const basePath = options.basePath;
     const specFile = options.specFile ?? `${target}.spec.ts`;
-    const errors = [];
-    const sections = [`# ${target}`];
-    // Verify spec file naming matches the primary target
-    if (!specFile.endsWith(".spec.ts")) {
-        errors.push({
-            type: "spec-name-mismatch",
-            message: `Spec file "${specFile}" must end with .spec.ts`,
-        });
-    }
-    else {
-        const baseName = (0, node_path_1.basename)(specFile, ".spec.ts");
-        if (baseName !== target) {
-            errors.push({
-                type: "spec-name-mismatch",
-                message: `Spec file "${specFile}" doesn't match target "${target}". Expected "${target}.spec.ts".`,
-            });
-        }
-    }
-    // maxRules check
-    const ruleCount = Object.keys(spec.rules).length;
-    if (options.maxRules && ruleCount > options.maxRules) {
-        errors.push({
-            type: "invalid-rule",
-            message: `${String(ruleCount)} rules exceeds maxRules limit of ${String(options.maxRules)}. Split into subdirectory specs.`,
-        });
-    }
+    const errors = [
+        ...specNameErrors(specFile, target),
+        ...ruleCountErrors(spec, options.maxRules),
+    ];
     // Per-spec maxSectionLines takes precedence, then compile options
     const maxSectionLines = spec.maxSectionLines ?? options.maxSectionLines;
-    const prose = await compileSectionsSection(spec, basePath, maxSectionLines);
+    const out = compiledPathOf(specFile);
+    const proseErrors = await compileSectionsSection(spec, basePath, out, maxSectionLines);
     const keyFiles = compileKeyFilesSection(spec, basePath);
     const commands = compileCommandsSection(spec, basePath);
     const rules = compileRulesSection(spec, basePath, options);
-    sections.push(...prose.lines, ...keyFiles.lines, ...commands.lines, ...rules.lines);
-    errors.push(...prose.errors, ...keyFiles.errors, ...commands.errors, ...rules.errors);
-    const body = sections.join("\n\n") + "\n";
+    errors.push(...proseErrors, ...keyFiles.errors, ...commands.errors, ...rules.errors);
+    // The file at `at`, headed `heading`. Every link in it is written from
+    // `at`'s own directory, so each target is rendered for its own path.
+    const bodyAt = (heading, at) => [
+        `# ${heading}`,
+        ...renderSections(spec, at),
+        ...keyFiles.lines,
+        ...commands.lines,
+        ...rules.render(at),
+    ].join("\n\n") + "\n";
+    const body = bodyAt(target, out);
     const tokens = estimateTokens(body);
     // Per-spec maxTokens takes precedence, then compile options. An explicit
     // ceiling is an error at any `compile-budget` severity, as it always was:
@@ -764,7 +884,7 @@ async function compileClaude(spec, options = {}) {
         : [
             ...checkContentBudgets({
                 spec,
-                renderedRules: rules.lines.join("\n\n"),
+                renderedRules: rules.render(out).join("\n\n"),
             }, specFile, resolveBudgetLimits(options, severity)),
         ];
     return {
@@ -775,17 +895,24 @@ async function compileClaude(spec, options = {}) {
         warnings: severity === "warn" ? budgetFindings : [],
         budgetFindings,
         linterResults: rules.linterResults,
+        enforceVerdicts: rules.enforceVerdicts,
         tokens,
         targets: allTargets,
+        outputs: allTargets.map((t, i) => {
+            if (i === 0)
+                return { path: out, markdown };
+            const path = (0, frame_js_1.targetBeside)(out, t);
+            return { path, markdown: addHash(bodyAt(t, path), specFile) };
+        }),
     };
 }
 // ---------------------------------------------------------------------------
 // Compile SKILL.md spec → markdown
 // ---------------------------------------------------------------------------
-function renderBody(body) {
+function renderBody(body, out) {
     if (typeof body === "string")
         return body;
-    return body.map(renderFragment).join("");
+    return body.map((f) => renderFragment(f, out)).join("");
 }
 /** Derive the `argument-hint` frontmatter value from typed inputs. */
 function renderArgumentHint(inputs) {
@@ -826,17 +953,17 @@ function renderGate(gate, retry) {
     };
 }
 /** Render the `## Steps` checklist with a gate per step. */
-function renderSteps(steps) {
-    const out = ["## Steps", ""];
+function renderSteps(steps, out) {
+    const lines = ["## Steps", ""];
     steps.forEach((s, idx) => {
-        out.push(`### Step ${String(idx + 1)}`, "");
-        out.push(renderBody(s.do).trim(), "");
+        lines.push(`### Step ${String(idx + 1)}`, "");
+        lines.push(renderBody(s.do, out).trim(), "");
         if (s.gate) {
             const g = renderGate(s.gate, s.retry);
-            out.push(g.prose, "", g.marker, "");
+            lines.push(g.prose, "", g.marker, "");
         }
     });
-    return out.join("\n").trimEnd();
+    return lines.join("\n").trimEnd();
 }
 /** Render the `## Result` postcondition gate. */
 function renderResult(result) {
@@ -982,15 +1109,15 @@ function renderSkillFrontmatter(spec, keys = dialect_js_1.RENDERABLE_SKILL_FRONT
  * the gated Steps, then the Result. body + steps compose — a skill can carry
  * both a rich reference body and a verified procedure.
  */
-function renderSkillSections(spec) {
+function renderSkillSections(spec, out) {
     const sections = [];
     if (spec.inputs && spec.inputs.length > 0) {
         sections.push(renderArguments(spec.inputs));
     }
     if (spec.body !== undefined)
-        sections.push(renderBody(spec.body).trim());
+        sections.push(renderBody(spec.body, out).trim());
     if (spec.steps && spec.steps.length > 0) {
-        sections.push(renderSteps(spec.steps));
+        sections.push(renderSteps(spec.steps, out));
     }
     if (spec.postcondition)
         sections.push(renderResult(spec.postcondition));
@@ -1040,7 +1167,7 @@ function checkInlineCode(markdown, max) {
 /**
  * Compile a SkillSpec into SKILL.md markdown with YAML frontmatter.
  */
-async 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
@@ -1049,7 +1176,7 @@ async function compileSkill(spec, options = {}) {
     // section AND its reference verification, silently. Doing it here rather than
     // in the readers means a reader added later cannot reintroduce the gap.
     spec = (0, skill_normalize_js_1.foldLegacyPostcondition)(spec);
-    const basePath = options.basePath ?? process.cwd();
+    const basePath = options.basePath;
     const specFile = options.specFile ?? "SKILL.md.spec.ts";
     const frontmatterKeys = options.dialect?.skillFrontmatterKeys ?? dialect_js_1.RENDERABLE_SKILL_FRONTMATTER_KEYS;
     const errors = [];
@@ -1115,7 +1242,7 @@ async function compileSkill(spec, options = {}) {
             errors.push({ type: "unknown-tool", message: issue.message });
         }
     }
-    const sections = renderSkillSections(spec);
+    const sections = renderSkillSections(spec, compiledPathOf(specFile));
     // Over-long inline code blocks are WARNINGS, not errors — they don't block
     // compilation (so adoption always compiles), just nudge toward file().
     const warnings = checkInlineCode(sections, spec.maxInlineCodeLines ?? DEFAULT_MAX_INLINE_CODE_LINES);
@@ -1201,7 +1328,7 @@ function purityMarker(purity) {
     return `<!-- vigiles:purity:${level} -->`;
 }
 /** Render the subagent's named `##` system-prompt sections (verified like CLAUDE.md). */
-async function renderAgentSections(sections, basePath) {
+async function renderAgentSections(sections, basePath, out) {
     const lines = [];
     const errors = [];
     for (const [name, content] of Object.entries(sections)) {
@@ -1218,7 +1345,7 @@ async function renderAgentSections(sections, basePath) {
         }
         else {
             errors.push(...(await validateRefs(content, basePath)));
-            const rendered = content.map(renderFragment).join("");
+            const rendered = renderBody(content, out);
             errors.push(...validateSectionContent(name, rendered));
             lines.push(`## ${heading}\n\n${rendered.trim()}`);
         }
@@ -1259,13 +1386,26 @@ function renderOutputContract(contract) {
         "```",
     ].join("\n");
 }
-/** Render the rules a subagent must follow as a `## Rules` section. */
-function renderAgentRules(rules) {
-    const parts = ["## Rules", ""];
-    for (const [id, rule] of Object.entries(rules)) {
-        parts.push(compileRule(id, rule), "");
-    }
-    return parts.join("\n").trim();
+/**
+ * Render the rules a subagent must follow as a `## Rules` section. Each
+ * `enforce()` is verified the same way `compileClaude` verifies it, so the
+ * marker is the verdict's and a missing or switched-off rule is an error here
+ * too (#351).
+ */
+function renderAgentRules(rules, basePath, out, verify) {
+    const rendered = Object.entries(rules).map(([id, rule]) => {
+        if (rule._kind !== "enforce")
+            return { text: compileRule(id, rule, out) };
+        const check = verifyEnforce(rule, basePath, verify);
+        return {
+            text: compileRule(id, rule, out, check.verdict),
+            error: check.error,
+        };
+    });
+    return {
+        text: ["## Rules", ...rendered.flatMap((r) => ["", r.text])].join("\n"),
+        errors: rendered.flatMap((r) => ("error" in r && r.error ? [r.error] : [])),
+    };
 }
 /**
  * Compile an AgentSpec into a subagent markdown file with YAML frontmatter.
@@ -1273,7 +1413,7 @@ function renderAgentRules(rules) {
  * carries (`vigiles:symbol`, file/cmd refs) are the same ones `lint` re-checks.
  */
 async function compileAgent(spec, options) {
-    const basePath = options.basePath ?? process.cwd();
+    const basePath = options.basePath;
     const specFile = options.specFile ?? "agent.md.spec.ts";
     const dialect = options.dialect;
     const errors = [];
@@ -1309,16 +1449,19 @@ async function compileAgent(spec, options) {
     if (Array.isArray(spec.body)) {
         errors.push(...(await validateRefs(spec.body, basePath)));
     }
+    const out = compiledPathOf(specFile);
     const sections = [];
     if (spec.body !== undefined)
-        sections.push(renderBody(spec.body).trim());
+        sections.push(renderBody(spec.body, out).trim());
     if (spec.sections) {
-        const result = await renderAgentSections(spec.sections, basePath);
+        const result = await renderAgentSections(spec.sections, basePath, out);
         sections.push(...result.lines);
         errors.push(...result.errors);
     }
     if (spec.rules && Object.keys(spec.rules).length > 0) {
-        sections.push(renderAgentRules(spec.rules));
+        const agentRules = renderAgentRules(spec.rules, basePath, out, options);
+        sections.push(agentRules.text);
+        errors.push(...agentRules.errors);
     }
     if (spec.output)
         sections.push(renderOutputContract(spec.output));