@warpgogol/forge 4.1.5 → 4.2.1

package/dist/os/rfc/handlers/validate-rules.js

@@ -0,0 +1,907 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Per-RFC validation rules (V-01..V-34, RFC-DIR-01) extracted from the validate handler for modularity.</purpose>
+<non-goals>
+  <item>Do not introduce app-specific runtime composition or deployment behavior into this reusable package source file.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0303 Phase 3: extracted from validate.ts as part of the handler split.</item>
+  <item>RFC-0722: add RFC-DIR-01 directory structure warning rule for unsanctioned subdirectories.</item>
+  <item>RFC-0755: add V-RFC-33 frontmatter YAML parseability check (checkFrontmatterYamlParse helper).</item>
+  <item>RFC-0795: add V-33 dependsOn referential integrity/self-dependency/rejected-dependency and V-34 batch slug format rules.</item>
+  <item>RFC-0997: add V-35 probe→criterion referential integrity, V-36 criterion identifier discipline, V-37 evidence mechanism validity, and computeProbeCoverage for non-blocking coverage reports.</item>
+  <item>RFC-1006: add V-38 document readiness completeness, V-39 non-atomic criterion, V-40 unbounded quantity, V-41 weasel verb, V-42 criterion versioning annotation format. Add evaluateDocumentReadiness and extend evaluateAcceptanceCriteria with supersession tracking and reject-checklist scans.</item>
+</CHANGE_SUMMARY>
+*/
+import path from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { parse as yamlParse } from "yaml";
+import { validateAcceptanceShape } from "../acceptance.js";
+import { RFC_DIR, RFC_ID_PATTERN, RFC_STATUSES, RFC_KINDS, RFC_SCOPES, RFC_FULL_REQUIRED_SECTIONS, RFC_METADATA_CUTOFF, RFC_VERSION_BUMP_CUTOFF, RFC_PROBE_BINDING_CUTOFF, RFC_CRITERIA_CONTENT_CUTOFF, } from "../types.js";
+import { DNA_DOCS, AP_DOCS } from "./shared.js";
+const DNA_DOC = DNA_DOCS[0];
+const AP_DOC = AP_DOCS[0];
+// RFC-0335: reviewer identity validation constants
+const REVIEWER_IDENTITY_PATTERN = /^(human|agent):[a-z0-9][a-z0-9-]*$/;
+const DECIDED_STATUSES = [
+    "accepted",
+    "implemented",
+    "rejected",
+    "superseded",
+];
+// ─── RFC-1006: reject checklist constants ──────────────────────────────────
+const UNBOUNDED_QUANTITY_TRIGGERS = [
+    "fast",
+    "quick",
+    "scalable",
+    "reasonable load",
+    "most requests",
+    "efficiently",
+    "high performance",
+    "low latency",
+    "responsively",
+    "smoothly",
+];
+const WEASEL_VERBS = [
+    "handle gracefully",
+    "behave correctly",
+    "as appropriate",
+    "robust",
+    "user-friendly",
+    "works correctly",
+    "is reliable",
+    "gracefully handle",
+    "correctly handle",
+    "properly handle",
+];
+// Detects "SHALL <verb-phrase> and <verb-phrase>" — non-atomic criterion.
+// Conservative: only fires when "and" appears after SHALL/SHOULD/MUST and
+// is followed by a verb-like word (a-z, not a noun-phrase connector).
+const NON_ATOMIC_PATTERN = /\b(?:SHALL|SHOULD|MUST)\s+\S[^()]*?\band\s+(?:return|report|exit|emit|write|read|create|delete|update|persist|validate|reject|accept|log|send|store|load|fetch|process|register|enqueue|schedule|trigger|notify|redirect|render|display|show|hide|enable|disable|start|stop|restart|check|verify|ensure|prevent|allow|block|deny|grant|revoke|parse|serialize|deserialize|encode|decode|compress|decompress|encrypt|decrypt|hash|sign|verify|transform|convert|map|filter|sort|group|aggregate|count|sum|average|min|max|find|search|resolve|lookup)\b/i;
+const SUPERSEDED_ANNOTATION_PATTERN = /^>\s*Superseded\s+(AC-\d+)\s+\((\d{4}-\d{2}-\d{2})\):\s*(.+)$/;
+/**
+ * Strip fenced code blocks (``` ... ```) from a markdown body.
+ * Prevents section extractors from matching headings inside code block examples.
+ * Pure function — no I/O, no side effects.
+ */
+export function stripFencedCodeBlocks(body) {
+    return body.replace(/```[\s\S]*?```/g, "");
+}
+/**
+ * Extract the raw document-readiness section text from an RFC body.
+ * Pure function — no I/O, no side effects.
+ */
+export function extractDocumentReadinessSection(body) {
+    const stripped = stripFencedCodeBlocks(body);
+    const match = stripped.match(/## Document readiness\s*\n([\s\S]*?)(?=\n## |\n*$)/);
+    return match ? match[1] : null;
+}
+/**
+ * Evaluate document-readiness checkboxes (RFC-1006).
+ * Pure function — no I/O, no side effects.
+ */
+export function evaluateDocumentReadiness(body) {
+    const section = extractDocumentReadinessSection(body);
+    if (!section) {
+        return {
+            totalChecked: 0,
+            totalUnchecked: 0,
+            uncheckedLines: [],
+            criterionIds: [],
+            linesWithoutId: [],
+        };
+    }
+    const uncheckedLines = section
+        .split("\n")
+        .filter((line) => /^- \[ \]/.test(line))
+        .map((line) => line.trim());
+    const totalUnchecked = uncheckedLines.length;
+    const checkedLines = section.split("\n").filter((line) => /^- \[x\]/.test(line));
+    const checklistLines = section.split("\n").filter((line) => /^- \[[ x]\]/.test(line));
+    const criterionIds = [];
+    const linesWithoutId = [];
+    for (const line of checklistLines) {
+        const match = line.match(/^\s*- \[[ x]\]\s*DR-(\d+):/);
+        if (match) {
+            criterionIds.push(`DR-${match[1]}`);
+        }
+        else {
+            linesWithoutId.push(line.trim());
+        }
+    }
+    return {
+        totalChecked: checkedLines.length,
+        totalUnchecked,
+        uncheckedLines,
+        criterionIds,
+        linesWithoutId,
+    };
+}
+/**
+ * Extract the raw acceptance-criteria section text from an RFC body.
+ * Returns `undefined` when the section is absent.
+ */
+export function extractAcceptanceCriteriaSection(body) {
+    const stripped = stripFencedCodeBlocks(body);
+    const match = stripped.match(/## Acceptance criteria\s*\n([\s\S]*?)(?=\n## |\n*$)/);
+    return match?.[1];
+}
+/**
+ * Evaluate acceptance criteria checkboxes and inline evidence annotations.
+ * Pure function — no I/O, no side effects. Used by both V-26/V-27 validation
+ * and the `rfc.implement.stamp` precondition checks (RFC-0476).
+ */
+export function evaluateAcceptanceCriteria(body) {
+    const section = extractAcceptanceCriteriaSection(body);
+    if (!section) {
+        return {
+            totalChecked: 0,
+            totalUnchecked: 0,
+            uncheckedLines: [],
+            checkedWithoutEvidence: [],
+            criterionIds: [],
+            duplicateCriterionIds: [],
+            linesWithoutId: [],
+            supersededIds: [],
+            nonAtomicViolations: [],
+            unboundedQuantityViolations: [],
+            weaselVerbViolations: [],
+            malformedSupersessionAnnotations: [],
+        };
+    }
+    const uncheckedLines = section
+        .split("\n")
+        .filter((line) => /^- \[ \]/.test(line))
+        .map((line) => line.trim());
+    const checkedLines = section.split("\n").filter((line) => /^- \[x\]/.test(line));
+    const checkedWithoutEvidence = [];
+    for (const line of checkedLines) {
+        if (!/\(evidence:\s*.+\)/.test(line)) {
+            checkedWithoutEvidence.push(line.trim());
+        }
+    }
+    const checklistLines = section.split("\n").filter((line) => /^- \[[ x]\]/.test(line));
+    const criterionIds = [];
+    const seenIds = new Set();
+    const duplicateCriterionIds = [];
+    const linesWithoutId = [];
+    for (const line of checklistLines) {
+        const match = line.match(/^\s*- \[[ x]\]\s*AC-(\d+):/);
+        if (match) {
+            const id = `AC-${match[1]}`;
+            if (seenIds.has(id)) {
+                duplicateCriterionIds.push(id);
+            }
+            else {
+                seenIds.add(id);
+                criterionIds.push(id);
+            }
+        }
+        else {
+            linesWithoutId.push(line.trim());
+        }
+    }
+    // RFC-1006: detect supersession annotations and exclude superseded criteria
+    const sectionLines = section.split("\n");
+    const supersededIds = [];
+    const supersededSet = new Set();
+    const malformedSupersessionAnnotations = [];
+    for (let i = 0; i < sectionLines.length; i++) {
+        const line = sectionLines[i];
+        const annMatch = line.match(SUPERSEDED_ANNOTATION_PATTERN);
+        if (annMatch) {
+            const acId = annMatch[1];
+            const dateStr = annMatch[2];
+            supersededIds.push(acId);
+            supersededSet.add(acId);
+            // Validate date format (already captured by regex, but check range)
+            const date = new Date(dateStr);
+            if (isNaN(date.getTime())) {
+                malformedSupersessionAnnotations.push(line.trim());
+            }
+        }
+        else if (/^>\s*Superseded\s+AC-/.test(line.trim()) &&
+            !SUPERSEDED_ANNOTATION_PATTERN.test(line.trim())) {
+            // Line starts with supersession annotation pattern but doesn't match full format
+            malformedSupersessionAnnotations.push(line.trim());
+        }
+    }
+    // Remove superseded criteria from unchecked count
+    const effectiveUncheckedLines = uncheckedLines.filter((line) => {
+        const match = line.match(/^\s*- \[ \]\s*AC-(\d+):/);
+        if (match) {
+            return !supersededSet.has(`AC-${match[1]}`);
+        }
+        return true;
+    });
+    // RFC-1006: reject checklist scans on criterion text
+    const nonAtomicViolations = [];
+    const unboundedQuantityViolations = [];
+    const weaselVerbViolations = [];
+    for (const line of checklistLines) {
+        const acMatch = line.match(/^\s*- \[[ x]\]\s*(AC-\d+):/);
+        if (!acMatch)
+            continue;
+        const acId = acMatch[1];
+        if (supersededSet.has(acId))
+            continue;
+        const text = line.toLowerCase();
+        // V-39: non-atomic criterion
+        if (NON_ATOMIC_PATTERN.test(line)) {
+            nonAtomicViolations.push({ line: line.trim(), acId });
+        }
+        // V-40: unbounded quantity
+        for (const trigger of UNBOUNDED_QUANTITY_TRIGGERS) {
+            if (text.includes(trigger)) {
+                unboundedQuantityViolations.push({ line: line.trim(), acId, trigger });
+            }
+        }
+        // V-41: weasel verbs
+        for (const trigger of WEASEL_VERBS) {
+            if (text.includes(trigger)) {
+                weaselVerbViolations.push({ line: line.trim(), acId, trigger });
+            }
+        }
+    }
+    return {
+        totalChecked: checkedLines.length,
+        totalUnchecked: effectiveUncheckedLines.length,
+        uncheckedLines: effectiveUncheckedLines,
+        checkedWithoutEvidence,
+        criterionIds,
+        duplicateCriterionIds,
+        linesWithoutId,
+        supersededIds,
+        nonAtomicViolations,
+        unboundedQuantityViolations,
+        weaselVerbViolations,
+        malformedSupersessionAnnotations,
+    };
+}
+// ─── RFC-0997: probe-criterion binding and coverage ────────────────────────
+/**
+ * Compute a non-blocking probe coverage report for an RFC.
+ * Pure function — no I/O, no side effects.
+ */
+export function computeProbeCoverage(criterionIds, acceptance) {
+    const probes = Array.isArray(acceptance) ? acceptance : [];
+    const probeBackedCriteria = new Set();
+    const unboundProbes = [];
+    for (const probe of probes) {
+        const criterion = probe.criterion;
+        if (typeof criterion === "string" && /^AC-\d+$/.test(criterion)) {
+            if (criterionIds.includes(criterion)) {
+                probeBackedCriteria.add(criterion);
+            }
+            else {
+                unboundProbes.push(criterion);
+            }
+        }
+        else {
+            unboundProbes.push(String(criterion ?? "(missing)"));
+        }
+    }
+    const uncoveredCriteria = criterionIds.filter((id) => !probeBackedCriteria.has(id));
+    const totalCriteria = criterionIds.length;
+    const probeBackedCount = probeBackedCriteria.size;
+    return {
+        totalCriteria,
+        probeBackedCriteria: probeBackedCount,
+        coverageRatio: totalCriteria > 0 ? probeBackedCount / totalCriteria : 0,
+        unboundProbes,
+        uncoveredCriteria,
+    };
+}
+// ─── RFC-0625: V-32 implementation commit drift detection ──────────────────
+function execGitLog(workspaceRoot, args) {
+    return new Promise((resolve) => {
+        execFile("git", args, { cwd: workspaceRoot, timeout: 10000 }, (err, stdout) => {
+            if (err) {
+                resolve("");
+                return;
+            }
+            resolve(stdout.trim());
+        });
+    });
+}
+async function checkImplementationCommitDrift(workspaceRoot, rfcId, createdAt, currentStatus) {
+    if (currentStatus === "implemented") {
+        return { found: false, commitCount: 0 };
+    }
+    const datePattern = /^\d{4}-\d{2}-\d{2}$/;
+    if (!datePattern.test(createdAt)) {
+        return { found: false, commitCount: 0 };
+    }
+    const log = await execGitLog(workspaceRoot, ["log", `--since=${createdAt}`, "--oneline"]);
+    if (!log) {
+        return { found: false, commitCount: 0 };
+    }
+    const pattern = new RegExp(`implement:\\s+${rfcId}\\b`, "i");
+    const matchingLines = log.split("\n").filter((line) => pattern.test(line.trim()));
+    return { found: matchingLines.length > 0, commitCount: matchingLines.length };
+}
+// ─── RFC-0709: V-NC-01 NEEDS CLARIFICATION marker detection ────────────────
+const NC_MARKER_CUTOFF = "2026-08-06";
+const NC_MARKER_PATTERN = /^>\s*NEEDS CLARIFICATION:\s*(.+)$/;
+/**
+ * Collect NEEDS CLARIFICATION markers from an RFC body.
+ * Skips lines inside fenced code blocks. Pure function — no I/O.
+ */
+export function collectMarkers(body, status, createdAt) {
+    if (createdAt < NC_MARKER_CUTOFF)
+        return [];
+    const severity = status === "draft" ? "warn" : "error";
+    const markers = [];
+    const lines = body.split("\n");
+    let inCodeBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^```/.test(line.trim())) {
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (inCodeBlock)
+            continue;
+        const match = line.match(NC_MARKER_PATTERN);
+        if (match) {
+            markers.push({
+                line: i + 1,
+                text: match[1].trim(),
+                severity,
+            });
+        }
+    }
+    return markers;
+}
+export async function validateSingleRfc(fileName, parsed, allParsed, seenIds, validDnaIds, validApIds, knownKeys, workspaceRoot, addViolation, seenFilenameNumbers) {
+    const fm = parsed.frontmatter;
+    const body = parsed.body;
+    const relFile = path.join(RFC_DIR, fileName);
+    const rfcId = String(fm["id"] ?? "UNKNOWN");
+    const isArchived = fileName.startsWith("archive/");
+    // V-01: id format
+    if (!RFC_ID_PATTERN.test(rfcId)) {
+        addViolation(rfcId, relFile, "V-01", `id "${rfcId}" does not match format RFC-XXXX`);
+    }
+    // RFC-DIR-01: directory structure convention (RFC-0722)
+    // Warn when RFC files are found in subdirectories other than archive/ and verification/
+    const slashIdx = fileName.indexOf("/");
+    if (slashIdx > 0) {
+        const subDir = fileName.slice(0, slashIdx);
+        if (subDir !== "archive" && subDir !== "verification") {
+            addViolation(rfcId, relFile, "RFC-DIR-01", `${relFile} is in an unsanctioned subdirectory. Only archive/ and verification/ are allowed. Move the file to docs/rfcs/ root or write an ADR to formalize the subdirectory.`, "warning");
+        }
+    }
+    // V-02: id uniqueness
+    const prevFile = seenIds.get(rfcId);
+    if (prevFile) {
+        addViolation(rfcId, relFile, "V-02", `Duplicate id "${rfcId}" — also in ${prevFile}. ` +
+            `This happens when an RFC is created by scanning only the top-level docs/rfcs/ directory, missing archived RFCs under docs/rfcs/archive/. ` +
+            `Fix: renumber this RFC by deleting it and re-running rfc.create (or spec.materialize) which scans the full tree recursively.`);
+    }
+    else {
+        seenIds.set(rfcId, relFile);
+    }
+    // V-03: valid status
+    const status = String(fm["status"] ?? "");
+    if (!RFC_STATUSES.includes(status)) {
+        addViolation(rfcId, relFile, "V-03", `Invalid status "${status}". Must be one of: ${RFC_STATUSES.join(", ")}`);
+    }
+    // V-04: valid kind
+    const kind = String(fm["kind"] ?? "");
+    if (!RFC_KINDS.includes(kind)) {
+        addViolation(rfcId, relFile, "V-04", `Invalid kind "${kind}". Must be one of: ${RFC_KINDS.join(", ")}`);
+    }
+    // V-05: valid scope
+    const scope = String(fm["scope"] ?? "");
+    if (!RFC_SCOPES.includes(scope)) {
+        addViolation(rfcId, relFile, "V-05", `Invalid scope "${scope}". Must be one of: ${RFC_SCOPES.join(", ")}`);
+    }
+    // V-06: owners non-empty
+    const owners = fm["owners"];
+    if (!Array.isArray(owners) || owners.length === 0) {
+        addViolation(rfcId, relFile, "V-06", "owners must be a non-empty array");
+    }
+    // V-07: valid dates
+    const createdAt = String(fm["createdAt"] ?? "");
+    const updatedAt = String(fm["updatedAt"] ?? "");
+    const datePattern = /^\d{4}-\d{2}-\d{2}$/;
+    if (!datePattern.test(createdAt)) {
+        addViolation(rfcId, relFile, "V-07", `createdAt "${createdAt}" is not a valid ISO 8601 date (YYYY-MM-DD)`);
+    }
+    if (!datePattern.test(updatedAt)) {
+        addViolation(rfcId, relFile, "V-07", `updatedAt "${updatedAt}" is not a valid ISO 8601 date (YYYY-MM-DD)`);
+    }
+    const enhancedAt = fm["enhancedAt"];
+    if (enhancedAt && !datePattern.test(enhancedAt)) {
+        addViolation(rfcId, relFile, "V-07", `enhancedAt "${enhancedAt}" is not a valid ISO 8601 date (YYYY-MM-DD)`);
+    }
+    // V-08: implementedAt >= createdAt
+    const implementedAt = fm["implementedAt"];
+    if (implementedAt && datePattern.test(implementedAt) && datePattern.test(createdAt)) {
+        if (implementedAt < createdAt) {
+            addViolation(rfcId, relFile, "V-08", `implementedAt (${implementedAt}) precedes createdAt (${createdAt})`);
+        }
+    }
+    // V-08b: enhancedAt >= createdAt
+    if (enhancedAt && datePattern.test(enhancedAt) && datePattern.test(createdAt)) {
+        if (enhancedAt < createdAt) {
+            addViolation(rfcId, relFile, "V-08", `enhancedAt (${enhancedAt}) precedes createdAt (${createdAt})`);
+        }
+    }
+    // V-09: closedAt >= createdAt
+    const closedAt = fm["closedAt"];
+    if (closedAt && datePattern.test(closedAt) && datePattern.test(createdAt)) {
+        if (closedAt < createdAt) {
+            addViolation(rfcId, relFile, "V-09", `closedAt (${closedAt}) precedes createdAt (${createdAt})`);
+        }
+    }
+    // V-10: supersedes point to existing RFCs (+ V-12 forward back-link check)
+    const supersedes = fm["supersedes"];
+    if (Array.isArray(supersedes)) {
+        for (const ref of supersedes) {
+            const refStr = String(ref);
+            if (!refStr)
+                continue;
+            if (!allParsed.has(refStr)) {
+                addViolation(rfcId, relFile, "V-10", `supersedes "${refStr}" does not match any existing RFC`);
+            }
+            else {
+                const otherBy = String(allParsed.get(refStr).parsed.frontmatter["supersededBy"] ?? "");
+                if (otherBy !== rfcId) {
+                    addViolation(rfcId, relFile, "V-12", `${rfcId}.supersedes includes ${refStr}, but ${refStr}.supersededBy is "${otherBy || "(empty)"}" (expected ${rfcId})`, "warning");
+                }
+            }
+        }
+    }
+    // V-11: supersededBy points to existing RFC
+    // Skip for archived RFCs — superseding RFCs may have been themselves archived/removed
+    const supersededBy = fm["supersededBy"];
+    if (supersededBy && !allParsed.has(supersededBy) && !isArchived) {
+        addViolation(rfcId, relFile, "V-11", `supersededBy "${supersededBy}" does not match any existing RFC`);
+    }
+    // V-12 (reverse): supersededBy target must list this RFC in its supersedes
+    if (supersededBy && allParsed.has(supersededBy)) {
+        const otherFm = allParsed.get(supersededBy).parsed.frontmatter;
+        const otherSupersedes = otherFm["supersedes"];
+        if (!Array.isArray(otherSupersedes) || !otherSupersedes.map(String).includes(rfcId)) {
+            addViolation(rfcId, relFile, "V-12", `${rfcId} is supersededBy ${supersededBy}, but ${supersededBy}.supersedes does not include ${rfcId}`, "warning");
+        }
+    }
+    // V-17: strict supersession lifecycle
+    if (supersededBy && status !== "superseded") {
+        addViolation(rfcId, relFile, "V-17", `supersededBy is set (${supersededBy}) but status is "${status}" (expected "superseded")`, "warning");
+    }
+    // V-13: required H2 sections (all RFCs use the full template)
+    const requiredSections = RFC_FULL_REQUIRED_SECTIONS;
+    const headings = [...body.matchAll(/^##\s+(.+)$/gm)].map((m) => m[1].trim());
+    for (const section of requiredSections) {
+        if (!headings.includes(section)) {
+            const severity = status === "draft" ? "warning" : "error";
+            // Skip error-severity V-13 for archived RFCs — template requirements evolved after archival
+            if (severity === "error" && isArchived)
+                continue;
+            addViolation(rfcId, relFile, "V-13", `Missing required section "## ${section}"`, severity);
+        }
+    }
+    // V-14: acceptance criteria must have at least 3 checklist items
+    const acceptanceSection = extractAcceptanceCriteriaSection(body);
+    if (acceptanceSection) {
+        const checklistItems = acceptanceSection.match(/^- \[[ x]\]/gm);
+        const count = checklistItems?.length ?? 0;
+        if (count < 3) {
+            addViolation(rfcId, relFile, "V-14", `Acceptance criteria has ${count} checklist items; minimum is 3`, status === "draft" ? "warning" : "error");
+        }
+    }
+    // V-26: implemented RFCs must have all acceptance criteria checked (RFC-0463)
+    // V-27: every checked criterion must carry inline (evidence: ...) annotation (RFC-0463)
+    // RFC-0476: both use the shared evaluateAcceptanceCriteria function.
+    const criteriaEval = evaluateAcceptanceCriteria(body);
+    if (acceptanceSection) {
+        if (status === "implemented" && criteriaEval.totalUnchecked > 0 && !isArchived) {
+            addViolation(rfcId, relFile, "V-26", `status is "implemented" but ${criteriaEval.totalUnchecked} acceptance criteria are unchecked. ` +
+                `Complete the work or split deferred criteria into a follow-up RFC via supersede.`);
+        }
+        for (const line of criteriaEval.checkedWithoutEvidence) {
+            addViolation(rfcId, relFile, "V-27", `checked acceptance criterion lacks inline (evidence: ...) annotation: "${line}"`);
+        }
+        // V-35/V-36/V-37: probe-criterion binding rules (RFC-0997, post-cutoff only)
+        const isPostCutoff = createdAt >= RFC_PROBE_BINDING_CUTOFF && !isArchived;
+        if (isPostCutoff) {
+            const acceptance = fm["acceptance"];
+            const probes = Array.isArray(acceptance) ? acceptance : [];
+            // V-35: every probe SHALL declare criterion referencing an existing AC-N id
+            for (let i = 0; i < probes.length; i++) {
+                const probe = probes[i];
+                const criterion = probe.criterion;
+                if (criterion === undefined || criterion === null) {
+                    addViolation(rfcId, relFile, "V-35", `acceptance probe ${i} ("${probe.probe}") lacks required "criterion" field (post-cutoff RFCs must bind probes to AC-N criteria per RFC-0997)`);
+                }
+                else if (typeof criterion !== "string" || !/^AC-\d+$/.test(criterion)) {
+                    addViolation(rfcId, relFile, "V-35", `acceptance probe ${i} ("${probe.probe}") has criterion "${String(criterion)}" which does not match format "AC-N"`);
+                }
+                else if (!criteriaEval.criterionIds.includes(criterion)) {
+                    addViolation(rfcId, relFile, "V-35", `acceptance probe ${i} ("${probe.probe}") declares criterion "${criterion}" which does not exist in acceptance criteria`);
+                }
+            }
+            // V-36: every top-level checklist line SHALL start with a unique AC-N: identifier
+            for (const line of criteriaEval.linesWithoutId) {
+                addViolation(rfcId, relFile, "V-36", `acceptance criterion checklist line lacks "AC-N:" identifier: "${line}"`);
+            }
+            for (const dupId of criteriaEval.duplicateCriterionIds) {
+                addViolation(rfcId, relFile, "V-36", `duplicate acceptance criterion identifier "${dupId}" — each AC-N must be unique`);
+            }
+            // V-37: checked criteria evidence SHALL resolve
+            if (acceptanceSection) {
+                const checkedLines = acceptanceSection
+                    .split("\n")
+                    .filter((line) => /^- \[x\]/.test(line));
+                for (const line of checkedLines) {
+                    const evidenceMatch = line.match(/\(evidence:\s*(.+?)\)/);
+                    if (!evidenceMatch)
+                        continue;
+                    const evidence = evidenceMatch[1].trim();
+                    if (evidence.startsWith("probe:")) {
+                        const refId = evidence.slice("probe:".length).trim();
+                        const hasProbe = probes.some((p) => p.criterion === refId);
+                        if (!criteriaEval.criterionIds.includes(refId)) {
+                            addViolation(rfcId, relFile, "V-37", `evidence "probe:${refId}" references a criterion that does not exist in acceptance criteria`);
+                        }
+                        else if (!hasProbe) {
+                            addViolation(rfcId, relFile, "V-37", `evidence "probe:${refId}" references a criterion with no bound probe`);
+                        }
+                    }
+                    else if (evidence.startsWith("test:")) {
+                        const testPath = evidence.slice("test:".length).trim();
+                        try {
+                            await stat(path.join(workspaceRoot, testPath));
+                        }
+                        catch {
+                            addViolation(rfcId, relFile, "V-37", `evidence "test:${testPath}" references a file that does not exist`);
+                        }
+                    }
+                    else if (/^[^:]+:\d+$/.test(evidence)) {
+                        const lastColon = evidence.lastIndexOf(":");
+                        const filePath = evidence.slice(0, lastColon).trim();
+                        try {
+                            await stat(path.join(workspaceRoot, filePath));
+                        }
+                        catch {
+                            addViolation(rfcId, relFile, "V-37", `evidence "${evidence}" references a file that does not exist`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // V-38..V-42: criteria content rules (RFC-1006, post-cutoff only)
+    const isCriteriaPostCutoff = createdAt >= RFC_CRITERIA_CONTENT_CUTOFF && !isArchived;
+    if (isCriteriaPostCutoff) {
+        const severity = status === "draft" ? "warning" : "error";
+        // V-38: document readiness completeness for accepted+ RFCs
+        const drEval = evaluateDocumentReadiness(body);
+        if (drEval.totalUnchecked > 0 && (status === "accepted" || status === "implemented")) {
+            addViolation(rfcId, relFile, "V-38", `status is "${status}" but ${drEval.totalUnchecked} document readiness criteria are unchecked in "## Document readiness" section.`, severity);
+        }
+        // V-39: non-atomic criterion
+        for (const v of criteriaEval.nonAtomicViolations) {
+            addViolation(rfcId, relFile, "V-39", `acceptance criterion ${v.acId} is non-atomic (contains "and" joining two behaviors): "${v.line}". Split into separate criteria.`, severity);
+        }
+        // V-40: unbounded quantity
+        for (const v of criteriaEval.unboundedQuantityViolations) {
+            addViolation(rfcId, relFile, "V-40", `acceptance criterion ${v.acId} contains unbounded quantity "${v.trigger}": state a specific number or reference the decision that will set it.`, severity);
+        }
+        // V-41: weasel verb
+        for (const v of criteriaEval.weaselVerbViolations) {
+            addViolation(rfcId, relFile, "V-41", `acceptance criterion ${v.acId} contains weasel verb "${v.trigger}": replace with a specific observable behavior.`, severity);
+        }
+        // V-42: malformed supersession annotation
+        for (const line of criteriaEval.malformedSupersessionAnnotations) {
+            addViolation(rfcId, relFile, "V-42", `malformed criterion supersession annotation (expected "> Superseded AC-N (YYYY-MM-DD): <reason>"): "${line}"`, "error");
+        }
+    }
+    // V-15: title consistency
+    const titleStr = String(fm["title"] ?? "");
+    const headingMatch = body.match(/^#\s+(?:RFC-\d{4}:\s*)?(.+)$/m);
+    if (headingMatch && titleStr) {
+        const headingTitle = headingMatch[1].trim();
+        if (headingTitle !== titleStr) {
+            addViolation(rfcId, relFile, "V-15", `Frontmatter title "${titleStr}" does not match body heading "${headingTitle}"`, "warning");
+        }
+    }
+    // V-16: status <-> date coupling
+    const implementedAtStr = String(fm["implementedAt"] ?? "");
+    const closedAtStr = String(fm["closedAt"] ?? "");
+    const isTerminalStatus = status === "superseded" || status === "rejected";
+    if (status === "implemented" && !implementedAtStr) {
+        addViolation(rfcId, relFile, "V-16", `status is "implemented" but implementedAt is empty`, "error");
+    }
+    if ((status === "accepted" || status === "draft") && implementedAtStr) {
+        addViolation(rfcId, relFile, "V-16", `status is "${status}" but implementedAt is set (${implementedAtStr})`, "error");
+    }
+    if (isTerminalStatus && !closedAtStr) {
+        addViolation(rfcId, relFile, "V-16", `status is "${status}" but closedAt is empty`, "warning");
+    }
+    if (!isTerminalStatus && closedAtStr) {
+        addViolation(rfcId, relFile, "V-16", `closedAt is set (${closedAtStr}) but status "${status}" is not terminal (superseded/rejected)`, "warning");
+    }
+    // V-18: referential integrity of related[]
+    const related = fm["related"];
+    if (Array.isArray(related)) {
+        for (const ref of related) {
+            const refStr = String(ref).trim();
+            if (!refStr)
+                continue;
+            if (/^RFC-\d{4}$/.test(refStr)) {
+                if (!allParsed.has(refStr)) {
+                    addViolation(rfcId, relFile, "V-18", `related "${refStr}" does not match any existing RFC`, "warning");
+                }
+            }
+            else if (/^DNA-\d+$/i.test(refStr) && validDnaIds.size > 0) {
+                if (!validDnaIds.has(parseInt(refStr.slice(4), 10))) {
+                    addViolation(rfcId, relFile, "V-18", `related "${refStr}" is not defined in ${DNA_DOC}`, "warning");
+                }
+            }
+            else if (/^AP-\d+$/i.test(refStr) && validApIds.size > 0) {
+                if (!validApIds.has(parseInt(refStr.slice(3), 10))) {
+                    addViolation(rfcId, relFile, "V-18", `related "${refStr}" is not defined in ${AP_DOC}`, "warning");
+                }
+            }
+        }
+    }
+    // V-19: amends/amendedBy referential + bidirectional integrity
+    const amends = fm["amends"];
+    if (Array.isArray(amends)) {
+        for (const ref of amends) {
+            const refStr = String(ref);
+            if (!refStr)
+                continue;
+            if (!allParsed.has(refStr)) {
+                addViolation(rfcId, relFile, "V-19", `amends "${refStr}" does not match any existing RFC`);
+            }
+            else {
+                const otherAmendedBy = allParsed.get(refStr).parsed.frontmatter["amendedBy"];
+                const arr = Array.isArray(otherAmendedBy) ? otherAmendedBy.map(String) : [];
+                if (!arr.includes(rfcId)) {
+                    addViolation(rfcId, relFile, "V-19", `${rfcId}.amends includes ${refStr}, but ${refStr}.amendedBy does not include ${rfcId}`, "warning");
+                }
+            }
+        }
+    }
+    const amendedBy = fm["amendedBy"];
+    if (Array.isArray(amendedBy)) {
+        for (const ref of amendedBy) {
+            const refStr = String(ref);
+            if (!refStr)
+                continue;
+            if (!allParsed.has(refStr)) {
+                addViolation(rfcId, relFile, "V-19", `amendedBy "${refStr}" does not match any existing RFC`);
+            }
+            else {
+                const otherAmends = allParsed.get(refStr).parsed.frontmatter["amends"];
+                const arr = Array.isArray(otherAmends) ? otherAmends.map(String) : [];
+                if (!arr.includes(rfcId)) {
+                    addViolation(rfcId, relFile, "V-19", `${rfcId}.amendedBy includes ${refStr}, but ${refStr}.amends does not include ${rfcId}`, "warning");
+                }
+            }
+        }
+    }
+    // V-21: filename must be lowercase kebab-case
+    const lowerRfcId = rfcId.toLowerCase();
+    const fileBasename = fileName.split("/").pop().split("\\").pop();
+    if (!fileBasename.startsWith(lowerRfcId)) {
+        addViolation(rfcId, relFile, "V-21", `Filename "${fileBasename}" must start with lowercase "${lowerRfcId}"`);
+    }
+    else if (!/^[a-z0-9-]+\.md$/.test(fileBasename)) {
+        addViolation(rfcId, relFile, "V-21", `Filename "${fileName}" is not lowercase kebab-case (only a-z, 0-9, hyphens allowed)`);
+    }
+    // V-20: no unknown frontmatter keys
+    for (const key of Object.keys(fm)) {
+        if (!knownKeys.has(key)) {
+            addViolation(rfcId, relFile, "V-20", `unknown frontmatter key "${key}" (not in the RFC schema)`, "warning");
+        }
+    }
+    // V-22: well-formed acceptance probe shape
+    for (const issue of validateAcceptanceShape(fm["acceptance"])) {
+        addViolation(rfcId, relFile, "V-22", issue.message, "warning");
+    }
+    // V-23: verification evidence for post-cutoff, probe-bearing, implemented RFCs
+    const createdAtStr = String(fm["createdAt"] ?? "");
+    const hasProbes = Array.isArray(fm["acceptance"]) && fm["acceptance"].length > 0;
+    if (createdAtStr >= RFC_METADATA_CUTOFF && hasProbes && status === "implemented") {
+        const slug = rfcId.toLowerCase();
+        const evidenceRelPath = path.join(RFC_DIR, "verification", `${slug}.generated.yaml`);
+        const evidenceAbsPath = path.join(workspaceRoot, evidenceRelPath);
+        let evidenceOk = false;
+        let evidenceOverall = "";
+        try {
+            const evidenceContent = await readFile(evidenceAbsPath, "utf-8");
+            const evidence = yamlParse(evidenceContent);
+            evidenceOverall = String(evidence.overall ?? "");
+            evidenceOk = evidenceOverall === "pass";
+        }
+        catch {
+            // file missing or unparseable
+        }
+        if (!evidenceOk) {
+            addViolation(rfcId, relFile, "V-23", `status is "implemented" with acceptance probes and createdAt >= ${RFC_METADATA_CUTOFF}, ` +
+                `but evidence file ${evidenceRelPath} is missing, unparseable, or overall is not "pass" ` +
+                `(got "${evidenceOverall || "missing"}"). Run: site-kernel run rfc.verification.emit --id ${rfcId}`);
+        }
+    }
+    // V-25: reviewer identity on newly decided RFCs (RFC-0335)
+    {
+        const reviewers = fm["reviewers"];
+        const reviewerArr = Array.isArray(reviewers) ? reviewers.map(String) : [];
+        const isDecided = DECIDED_STATUSES.includes(status);
+        const isPostCutoff = createdAtStr >= RFC_METADATA_CUTOFF;
+        if (isPostCutoff && isDecided && reviewerArr.length === 0) {
+            addViolation(rfcId, relFile, "V-25", `${status} RFC created ${createdAtStr} has empty reviewers — the deciding human must record their identity (RFC-0335).`);
+        }
+        for (const entry of reviewerArr) {
+            if (!REVIEWER_IDENTITY_PATTERN.test(entry)) {
+                addViolation(rfcId, relFile, "V-25", `reviewer "${entry}" does not match the identity format ^(human|agent):[a-z0-9][a-z0-9-]*$ (RFC-0335).`);
+            }
+            else if (entry.startsWith("agent:")) {
+                addViolation(rfcId, relFile, "V-25", `agent reviewer identities are reserved until an RFC grants AI reviewer authority over RFC governance (see RFC-0279 for the pattern) (RFC-0335).`);
+            }
+        }
+    }
+    // V-24: satisfies DNA-trace frontmatter (RFC-0331)
+    {
+        const satisfies = fm["satisfies"];
+        const satisfiesArr = Array.isArray(satisfies) ? satisfies.map(String) : [];
+        const satisfiesPresent = satisfiesArr.length > 0;
+        const kind = String(fm["kind"] ?? "");
+        const requiresSatisfies = createdAtStr >= RFC_METADATA_CUTOFF && (kind === "architecture" || kind === "contract");
+        // Format: all RFCs, any age — each entry must match ^DNA-\d+$
+        if (satisfiesPresent) {
+            for (const entry of satisfiesArr) {
+                if (!/^DNA-\d+$/.test(entry)) {
+                    addViolation(rfcId, relFile, "V-24", `satisfies entry "${entry}" does not match the format ^DNA-\\d+$ (RFC-0331).`);
+                }
+            }
+        }
+        // Presence: post-cutoff architecture/contract RFCs must have non-empty satisfies
+        if (requiresSatisfies && !satisfiesPresent) {
+            addViolation(rfcId, relFile, "V-24", `${kind} RFC created ${createdAtStr} (>= ${RFC_METADATA_CUTOFF}) must declare at least one DNA invariant in satisfies (RFC-0331).`);
+        }
+    }
+    // V-28: RFC-id monotonicity (RFC-0478) — no RFC may have an id lower
+    // than the maximum id among RFCs with a strictly earlier createdAt.
+    // Same-day RFCs (equal createdAt) are unconstrained relative to each other.
+    // Only applies to RFCs created strictly after RFC_VERSION_BUMP_CUTOFF;
+    // pre-cutoff and same-day RFCs predate the rule and are exempt.
+    // All RFCs (including pre-cutoff) participate in the comparison set.
+    {
+        const currentIdNum = parseInt(rfcId.replace(/^RFC-/, ""), 10);
+        const currentCreatedAt = String(fm["createdAt"] ?? "");
+        if (currentCreatedAt > RFC_VERSION_BUMP_CUTOFF) {
+            let maxEarlierId = 0;
+            for (const [otherId, other] of allParsed) {
+                if (otherId === rfcId)
+                    continue;
+                const otherCreatedAt = String(other.parsed.frontmatter["createdAt"] ?? "");
+                if (otherCreatedAt < currentCreatedAt) {
+                    const otherIdNum = parseInt(otherId.replace(/^RFC-/, ""), 10);
+                    if (otherIdNum > maxEarlierId) {
+                        maxEarlierId = otherIdNum;
+                    }
+                }
+            }
+            if (currentIdNum < maxEarlierId) {
+                addViolation(rfcId, relFile, "V-28", `RFC-id ${rfcId} (createdAt ${currentCreatedAt}) is lower than RFC-${maxEarlierId} which has a strictly earlier createdAt. RFC-ids must be monotonically non-decreasing with respect to createdAt (RFC-0478).`);
+            }
+        }
+    }
+    // V-29: versionBump required for post-cutoff accepted/implemented RFCs (RFC-0478, ADR-0029)
+    {
+        const versionBump = fm["versionBump"];
+        const isPostCutoff = createdAtStr >= RFC_VERSION_BUMP_CUTOFF;
+        const requiresVersionBump = status === "implemented" || status === "accepted";
+        if (isPostCutoff && requiresVersionBump && versionBump === undefined) {
+            addViolation(rfcId, relFile, "V-29", `status is "${status}" and createdAt >= ${RFC_VERSION_BUMP_CUTOFF}, but versionBump is absent. Post-cutoff accepted/implemented RFCs must declare versionBump (RFC-0478).`);
+        }
+        if (versionBump === "none") {
+            const commands = fm["commands"];
+            const added = Array.isArray(commands?.added) ? commands.added : [];
+            const changed = Array.isArray(commands?.changed) ? commands.changed : [];
+            if (added.length > 0 || changed.length > 0) {
+                addViolation(rfcId, relFile, "V-29", `versionBump is "none" but commands.added or commands.changed is non-empty. Commands imply code changes; use "patch" or "minor" instead (RFC-0478).`, "warning");
+            }
+        }
+    }
+    // V-30: breaksC field consistency (RFC-0480)
+    // If breaksC: true — @warpgogol/ontology must be in packagesImpacted.
+    // If breaksC absent/false but @warpgol/ontology in packagesImpacted — warning.
+    // Skip for archived RFCs — package names changed during ecosystem consolidation (RFC-0776):
+    // @warpgogol/ontology → @warpgogol/werkstatt-shared/ontology
+    {
+        const breaksC = fm["breaksC"];
+        const packagesImpacted = Array.isArray(fm["packagesImpacted"])
+            ? fm["packagesImpacted"].map(String)
+            : [];
+        const hasOntology = packagesImpacted.some((p) => p.includes("@warpgogol/werkstatt-shared/ontology"));
+        if (breaksC === true && !hasOntology && !isArchived) {
+            addViolation(rfcId, relFile, "V-30", `breaksC is true but @warpgogol/ontology is not in packagesImpacted. RFCs that break Layer C must update the declarative C-contract in packages/ontology/src/external-surfaces/ (RFC-0480).`);
+        }
+        if (breaksC !== true && hasOntology) {
+            addViolation(rfcId, relFile, "V-30", `@warpgogol/ontology is in packagesImpacted but breaksC is not true. If this RFC modifies packages/ontology/src/external-surfaces/, declare breaksC: true (RFC-0480).`, "warning");
+        }
+    }
+    // V-31: filename-number uniqueness and filename/id consistency (RFC-0491)
+    if (seenFilenameNumbers) {
+        const fileBasename = fileName.split("/").pop().split("\\").pop();
+        const fileNumMatch = fileBasename.match(/^rfc-(\d{4})/);
+        if (fileNumMatch) {
+            const fileNum = parseInt(fileNumMatch[1], 10);
+            const idNum = parseInt(rfcId.replace(/^RFC-/, ""), 10);
+            // Sub-check A: filename number must match frontmatter id number
+            if (!Number.isNaN(idNum) && fileNum !== idNum) {
+                addViolation(rfcId, relFile, "V-31", `Filename number ${String(fileNum).padStart(4, "0")} does not match frontmatter id ${rfcId}`);
+            }
+            // Sub-check B: filename number must be unique across the full tree
+            const prevNumFile = seenFilenameNumbers.get(fileNum);
+            if (prevNumFile) {
+                addViolation(rfcId, relFile, "V-31", `Duplicate filename number ${String(fileNum).padStart(4, "0")} — also in ${prevNumFile}`);
+            }
+            else {
+                seenFilenameNumbers.set(fileNum, relFile);
+            }
+        }
+    }
+    // V-32: implementation commit drift detection (RFC-0625)
+    // Warns when implement: RFC-XXXX commits exist in git history since createdAt
+    // but the RFC status is not yet "implemented".
+    {
+        const driftResult = await checkImplementationCommitDrift(workspaceRoot, rfcId, createdAt, status);
+        if (driftResult.found) {
+            addViolation(rfcId, relFile, "V-32", `${rfcId} has ${driftResult.commitCount} implement: commit(s) in git history since ${createdAt} but status is still "${status}". Run rfc.implement.stamp to transition to implemented.`, "warning");
+        }
+    }
+    // V-33: dependsOn referential integrity, self-dependency, rejected-dependency deadlock (RFC-0795)
+    const dependsOn = fm["dependsOn"];
+    if (Array.isArray(dependsOn)) {
+        for (const depRef of dependsOn) {
+            const depStr = String(depRef);
+            if (!depStr)
+                continue;
+            if (depStr === rfcId) {
+                addViolation(rfcId, relFile, "V-33", `dependsOn includes itself — an RFC cannot depend on itself`, "warning");
+            }
+            else if (!allParsed.has(depStr)) {
+                addViolation(rfcId, relFile, "V-33", `dependsOn "${depStr}" does not match any existing RFC`, "warning");
+            }
+            else {
+                const depStatus = String(allParsed.get(depStr).parsed.frontmatter["status"] ?? "");
+                if (depStatus === "rejected") {
+                    addViolation(rfcId, relFile, "V-33", `dependsOn "${depStr}" has status "rejected" — this dependency will never be satisfied. Remove the entry or supersede the rejected RFC.`, "warning");
+                }
+            }
+        }
+    }
+    // V-34: batch slug format (RFC-0795)
+    const batchSlug = fm["batch"];
+    if (batchSlug !== undefined && batchSlug !== null) {
+        const batchStr = String(batchSlug);
+        if (batchStr && !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(batchStr)) {
+            addViolation(rfcId, relFile, "V-34", `batch slug "${batchStr}" does not match kebab-case pattern /^[a-z0-9]+(-[a-z0-9]+)*$/`, "warning");
+        }
+    }
+    // V-NC-01: NEEDS CLARIFICATION marker detection (RFC-0709)
+    const ncMarkers = collectMarkers(body, status, createdAt);
+    for (const marker of ncMarkers) {
+        addViolation(rfcId, relFile, "V-NC-01", `Unresolved NEEDS CLARIFICATION marker at line ${marker.line}: "${marker.text}"`, marker.severity === "error" ? "error" : "warning");
+    }
+    return ncMarkers;
+}
+// ─── V-RFC-33: frontmatter YAML parseability (RFC-0755) ────────────────────
+export function checkFrontmatterYamlParse(fileName, result, addViolation) {
+    if (result && "error" in result) {
+        const relFile = path.join(RFC_DIR, fileName);
+        addViolation("UNKNOWN", relFile, "V-RFC-33", `RFC frontmatter YAML parse error in ${fileName}: ${result.error}`);
+    }
+}
+//# sourceMappingURL=validate-rules.js.map