@warpgogol/forge 2.21.6 → 2.21.8

package/os/rfc/acceptance.ts

@@ -14,6 +14,7 @@ prose checklist.
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
   <item>RFC-0268: initial implementation.</item>
+  <item>RFC-0998: added test and json-schema probe kinds — spawnVitest helper, Ajv validation, shape validation.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -21,6 +22,7 @@ import { spawn } from "node:child_process";
 import { stat, readFile } from "node:fs/promises";
 import path from "node:path";
 import { parse as yamlParse } from "yaml";
+import { Ajv } from "ajv";
 import type {
   Diagnostic,
   ForgeCommandInput,
@@ -28,9 +30,15 @@ import type {
   ForgeRuntimeContext,
   CommandRegistry,
 } from "../../src/types.ts";
-import type { AcceptanceProbe, ProbeResult, RfcAcceptanceRunResult } from "./types.ts";
-import { RFC_DIR } from "./types.ts";
+import type {
+  AcceptanceProbe,
+  ProbeResult,
+  RfcAcceptanceRunResult,
+  ProbeCoverageReport,
+} from "./types.ts";
+import { RFC_DIR, RFC_PROBE_BINDING_CUTOFF } from "./types.ts";
 import { listRfcFiles, readAndParseRfc } from "./frontmatter-io.ts";
+import { evaluateAcceptanceCriteria, computeProbeCoverage } from "./handlers/validate-rules.ts";
 
 const RUN_PROBE_ALLOWED_PREFIX = "werkstatt ";
 
@@ -138,10 +146,40 @@ export function validateAcceptanceShape(value: unknown): AcceptanceShapeIssue[]
         }
         break;
       }
+      case "test": {
+        const file = (entry as Record<string, unknown>)["file"];
+        if (typeof file !== "string") {
+          issues.push({ index, message: 'probe "test" requires a string "file"' });
+        }
+        const testName = (entry as Record<string, unknown>)["testName"];
+        if (testName !== undefined && typeof testName !== "string") {
+          issues.push({ index, message: 'probe "test" testName must be a string if present' });
+        }
+        const expect = (entry as Record<string, unknown>)["expect"];
+        if (
+          !expect ||
+          typeof expect !== "object" ||
+          typeof (expect as Record<string, unknown>)["exitCode"] !== "number"
+        ) {
+          issues.push({ index, message: 'probe "test" requires expect: { exitCode: <number> }' });
+        }
+        break;
+      }
+      case "json-schema": {
+        const artifact = (entry as Record<string, unknown>)["artifact"];
+        if (typeof artifact !== "string") {
+          issues.push({ index, message: 'probe "json-schema" requires a string "artifact"' });
+        }
+        const schemaInline = (entry as Record<string, unknown>)["schemaInline"];
+        if (!schemaInline || typeof schemaInline !== "object") {
+          issues.push({ index, message: 'probe "json-schema" requires an object "schemaInline"' });
+        }
+        break;
+      }
       default:
         issues.push({
           index,
-          message: `unknown probe kind "${String(probe)}" — expected one of: run, file-exists, file-contains, command-registered, page`,
+          message: `unknown probe kind "${String(probe)}" — expected one of: run, file-exists, file-contains, command-registered, page, test, json-schema`,
         });
     }
   });
@@ -189,6 +227,45 @@ async function spawnSiteKernel(
   });
 }
 
+async function spawnVitest(
+  workspaceRoot: string,
+  file: string,
+  testName?: string,
+): Promise<{ exitCode: number | null; timedOut: boolean }> {
+  const args = ["exec", "vitest", "run", file];
+  if (testName) {
+    args.push("-t", testName);
+  }
+
+  return new Promise((resolve) => {
+    const child = spawn("pnpm", args, {
+      cwd: workspaceRoot,
+      stdio: "ignore",
+    });
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill();
+      resolve({ exitCode: null, timedOut: true });
+    }, RUN_PROBE_TIMEOUT_MS);
+    timer.unref?.();
+
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ exitCode: code, timedOut: false });
+    });
+    child.on("error", () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ exitCode: null, timedOut: false });
+    });
+  });
+}
+
 /** Executes a single probe. Pure aside from its declared filesystem/process/registry effects. */
 export async function runProbe(
   probe: AcceptanceProbe,
@@ -247,6 +324,48 @@ export async function runProbe(
         detail: "page probe skipped — run qa.independent.run against a built dist",
       };
     }
+    case "test": {
+      const { exitCode, timedOut } = await spawnVitest(workspaceRoot, probe.file, probe.testName);
+      if (timedOut) {
+        return { probe, ok: false, detail: `timed out after ${RUN_PROBE_TIMEOUT_MS}ms` };
+      }
+      const ok = exitCode === probe.expect.exitCode;
+      return { probe, ok, detail: `exitCode=${exitCode} (expected ${probe.expect.exitCode})` };
+    }
+    case "json-schema": {
+      const artifactPath = path.join(workspaceRoot, probe.artifact);
+      let raw: string;
+      try {
+        raw = await readFile(artifactPath, "utf8");
+      } catch {
+        return { probe, ok: false, detail: "artifact file not found" };
+      }
+      let parsed: unknown;
+      const ext = path.extname(probe.artifact).toLowerCase();
+      try {
+        if (ext === ".yaml" || ext === ".yml") {
+          parsed = yamlParse(raw);
+        } else {
+          parsed = JSON.parse(raw);
+        }
+      } catch {
+        return { probe, ok: false, detail: "artifact file could not be parsed" };
+      }
+      try {
+        const ajv = new Ajv({ allErrors: false });
+        const validate = ajv.compile(probe.schemaInline);
+        const valid = validate(parsed);
+        if (valid) {
+          return { probe, ok: true, detail: "schema valid" };
+        }
+        const firstError = validate.errors?.[0];
+        const errorPath = firstError?.instancePath || "(root)";
+        const errorMessage = firstError?.message || "validation failed";
+        return { probe, ok: false, detail: `Ajv error at ${errorPath}: ${errorMessage}` };
+      } catch {
+        return { probe, ok: false, detail: "schema compilation failed" };
+      }
+    }
   }
 }
 
@@ -330,7 +449,17 @@ export async function runRfcAcceptanceRun(
         message: `${pageProbeCount} page probe(s) skipped — run \`qa.independent.run --site <app>\` against a built dist.`,
       });
     }
-    results.push({ rfcId, probeResults });
+
+    let rfcCoverage: ProbeCoverageReport | undefined;
+    const createdAt = String(fm["createdAt"] ?? "");
+    const isArchived = fileName.startsWith("archive/");
+    if (createdAt >= RFC_PROBE_BINDING_CUTOFF && !isArchived) {
+      const parsedBody = parsedFile.parsed.body;
+      const criteriaEval = evaluateAcceptanceCriteria(parsedBody);
+      rfcCoverage = computeProbeCoverage(criteriaEval.criterionIds, acceptance);
+    }
+
+    results.push({ rfcId, probeResults, coverage: rfcCoverage });
   }
 
   const failedCount = diagnostics.filter((d) => d.severity === "error").length;

package/os/rfc/handlers/implement-stamp.ts

@@ -15,6 +15,7 @@ verification evidence, and atomically mutates RFC frontmatter.
   <item>RFC-0476: initial implementation.</item>
   <item>RFC-0756: auto-detect implementation commit when --implementation-commit is omitted.</item>
   <item>RFC-0795: add RFC-IMP-07 dependsOn dependency gate — blocks stamping when any dependsOn entry is not implemented.</item>
+  <item>RFC-0997: add RFC-IMP-08 minimum-one-probe gate — blocks stamping for post-cutoff architecture/contract/command RFCs with no acceptance probes.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -33,7 +34,7 @@ import {
 } from "../frontmatter-io.ts";
 import { evaluateAcceptanceCriteria } from "./validate-rules.ts";
 import { toIsoDate } from "./shared.ts";
-import { RFC_DIR, RFC_METADATA_CUTOFF } from "../types.ts";
+import { RFC_DIR, RFC_METADATA_CUTOFF, RFC_PROBE_BINDING_CUTOFF } from "../types.ts";
 import type { RfcStatus, RfcImplementStampViolation, RfcImplementStampResult } from "../types.ts";
 import type {
   ForgeCommandInput,
@@ -399,6 +400,18 @@ export async function runRfcImplementStamp(
     }
   }
 
+  // ── RFC-IMP-08: minimum-one-probe gate (RFC-0997) ─────────────────────────
+  // Post-cutoff architecture/contract/command RFCs must declare at least one
+  // acceptance probe. Policy and deprecation kinds are exempt.
+  const rfcKind = String(fm["kind"] ?? "");
+  const probeGateKinds = new Set(["architecture", "contract", "command"]);
+  if (createdAtStr >= RFC_PROBE_BINDING_CUTOFF && probeGateKinds.has(rfcKind) && !hasProbes) {
+    violations.push({
+      rule: "RFC-IMP-08",
+      message: `RFC ${targetId} (kind: ${rfcKind}) has no acceptance probes. Post-cutoff architecture/contract/command RFCs require at least one probe (RFC-0997). See RFC-0996 for the authoring standard.`,
+    });
+  }
+
   // If any violations found, return without mutation
   if (violations.length > 0) {
     return stampFailResult(violations, isDryRun, outputFormat, logger);

package/os/rfc/handlers/validate-rules-rfc0997.test.ts

@@ -0,0 +1,394 @@
+import { test, expect, describe } from "vitest";
+import {
+  evaluateAcceptanceCriteria,
+  computeProbeCoverage,
+  type AddViolationFn,
+  validateSingleRfc,
+} from "./validate-rules.ts";
+import type { ParsedRfc } from "../frontmatter-io.ts";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const testWorkspace = join(tmpdir(), "test-workspace-rfc0997");
+
+function makeParsed(
+  status: string,
+  body: string,
+  extraFm: Record<string, unknown> = {},
+): ParsedRfc {
+  return {
+    frontmatter: {
+      id: "RFC-9999",
+      title: "Test RFC",
+      status,
+      kind: "command",
+      scope: "workspace",
+      owners: ["architecture"],
+      createdAt: "2026-09-01",
+      updatedAt: "2026-09-01",
+      ...extraFm,
+    },
+    body,
+  };
+}
+
+const BASE_BODY = `
+# RFC-9999: Test RFC
+
+## Context
+
+Test context.
+
+## Problem
+
+Test problem.
+
+## Decision
+
+Test decision.
+
+## Architectural fit
+
+Test fit.
+
+## Design
+
+### CLI surface
+
+Test CLI.
+
+### TypeScript contracts
+
+Test types.
+
+### File system responsibilities
+
+| Path | Role |
+|---|---|
+| \`test.ts\` | test |
+
+### Output format
+
+Test output.
+
+### Failure modes
+
+Test failures.
+
+## Rollout
+
+Test rollout.
+
+## Alternatives considered
+
+Test alternatives.
+
+## Risks
+
+Test risks.
+
+## Acceptance criteria
+
+ACCEPTANCE_HERE
+
+## Implementation notes for agents
+
+Test notes.
+`;
+
+function makeViolationsCollector(): {
+  add: AddViolationFn;
+  violations: { rfcId: string; rule: string; message: string; severity: string }[];
+} {
+  const violations: { rfcId: string; rule: string; message: string; severity: string }[] = [];
+  const add: AddViolationFn = (rfcId, _file, rule, message, severity = "error") => {
+    violations.push({ rfcId, rule, message, severity });
+  };
+  return { add, violations };
+}
+
+async function runValidate(
+  parsed: ParsedRfc,
+): Promise<{ rfcId: string; rule: string; message: string; severity: string }[]> {
+  const { add, violations } = makeViolationsCollector();
+  await validateSingleRfc(
+    "rfc-9999-test.md",
+    parsed,
+    new Map(),
+    new Map(),
+    new Set(),
+    new Set(),
+    new Set(Object.keys(parsed.frontmatter)),
+    testWorkspace,
+    add,
+  );
+  return violations;
+}
+
+function filterRule(
+  violations: { rfcId: string; rule: string; message: string; severity: string }[],
+  rule: string,
+): { rfcId: string; rule: string; message: string; severity: string }[] {
+  return violations.filter((v) => v.rule === rule);
+}
+
+// ─── evaluateAcceptanceCriteria: AC-N parsing ──────────────────────────────
+
+describe("evaluateAcceptanceCriteria: AC-N id parsing (RFC-0997)", () => {
+  test("parses AC-N ids from checklist lines", () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first criterion (evidence: test.ts:1)\n- [ ] AC-2: second criterion\n- [x] AC-3: third (evidence: test.ts:2)",
+    );
+    const result = evaluateAcceptanceCriteria(body);
+    expect(result.criterionIds).toEqual(["AC-1", "AC-2", "AC-3"]);
+    expect(result.duplicateCriterionIds).toEqual([]);
+    expect(result.linesWithoutId).toEqual([]);
+  });
+
+  test("detects duplicate AC-N ids", () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: test.ts:1)\n- [ ] AC-1: duplicate\n- [x] AC-2: third (evidence: test.ts:2)",
+    );
+    const result = evaluateAcceptanceCriteria(body);
+    expect(result.criterionIds).toEqual(["AC-1", "AC-2"]);
+    expect(result.duplicateCriterionIds).toEqual(["AC-1"]);
+  });
+
+  test("detects checklist lines without AC-N prefix", () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: test.ts:1)\n- [ ] no id here\n- [x] AC-2: third (evidence: test.ts:2)",
+    );
+    const result = evaluateAcceptanceCriteria(body);
+    expect(result.linesWithoutId).toEqual(["- [ ] no id here"]);
+  });
+});
+
+// ─── computeProbeCoverage ───────────────────────────────────────────────────
+
+describe("computeProbeCoverage (RFC-0997)", () => {
+  test("full coverage when all criteria have probes", () => {
+    const ids = ["AC-1", "AC-2", "AC-3"];
+    const acceptance = [
+      { probe: "file-exists", path: "a.ts", criterion: "AC-1" },
+      { probe: "file-exists", path: "b.ts", criterion: "AC-2" },
+      { probe: "file-exists", path: "c.ts", criterion: "AC-3" },
+    ];
+    const report = computeProbeCoverage(ids, acceptance);
+    expect(report.totalCriteria).toBe(3);
+    expect(report.probeBackedCriteria).toBe(3);
+    expect(report.coverageRatio).toBe(1);
+    expect(report.uncoveredCriteria).toEqual([]);
+    expect(report.unboundProbes).toEqual([]);
+  });
+
+  test("partial coverage when some criteria lack probes", () => {
+    const ids = ["AC-1", "AC-2", "AC-3"];
+    const acceptance = [
+      { probe: "file-exists", path: "a.ts", criterion: "AC-1" },
+      { probe: "file-exists", path: "b.ts", criterion: "AC-2" },
+    ];
+    const report = computeProbeCoverage(ids, acceptance);
+    expect(report.totalCriteria).toBe(3);
+    expect(report.probeBackedCriteria).toBe(2);
+    expect(report.coverageRatio).toBeCloseTo(0.667, 2);
+    expect(report.uncoveredCriteria).toEqual(["AC-3"]);
+  });
+
+  test("unbound probe references nonexistent criterion", () => {
+    const ids = ["AC-1"];
+    const acceptance = [
+      { probe: "file-exists", path: "a.ts", criterion: "AC-1" },
+      { probe: "file-exists", path: "b.ts", criterion: "AC-99" },
+    ];
+    const report = computeProbeCoverage(ids, acceptance);
+    expect(report.unboundProbes).toEqual(["AC-99"]);
+  });
+
+  test("probe without criterion field is unbound", () => {
+    const ids = ["AC-1"];
+    const acceptance = [{ probe: "file-exists", path: "a.ts" }];
+    const report = computeProbeCoverage(ids, acceptance);
+    expect(report.unboundProbes).toEqual(["(missing)"]);
+    expect(report.probeBackedCriteria).toBe(0);
+  });
+
+  test("zero criteria and zero probes gives ratio 0", () => {
+    const report = computeProbeCoverage([], []);
+    expect(report.totalCriteria).toBe(0);
+    expect(report.coverageRatio).toBe(0);
+  });
+});
+
+// ─── V-35: probe→criterion referential integrity ───────────────────────────
+
+describe("V-35: probe→criterion referential integrity (RFC-0997)", () => {
+  test("post-cutoff probe without criterion fires V-35", async () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: test.ts:1)\n- [ ] AC-2: second\n- [x] AC-3: third (evidence: test.ts:2)",
+    );
+    const parsed = makeParsed("accepted", body, {
+      acceptance: [{ probe: "file-exists", path: "a.ts" }],
+    });
+    const violations = await runValidate(parsed);
+    const v35 = filterRule(violations, "V-35");
+    expect(v35.length).toBeGreaterThanOrEqual(1);
+    expect(v35[0]!.message).toContain('lacks required "criterion"');
+  });
+
+  test("post-cutoff probe with nonexistent criterion fires V-35", async () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: test.ts:1)\n- [ ] AC-2: second\n- [x] AC-3: third (evidence: test.ts:2)",
+    );
+    const parsed = makeParsed("accepted", body, {
+      acceptance: [{ probe: "file-exists", path: "a.ts", criterion: "AC-99" }],
+    });
+    const violations = await runValidate(parsed);
+    const v35 = filterRule(violations, "V-35");
+    expect(v35.length).toBeGreaterThanOrEqual(1);
+    expect(v35[0]!.message).toContain("does not exist");
+  });
+
+  test("post-cutoff probe with valid criterion does NOT fire V-35", async () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: test.ts:1)\n- [ ] AC-2: second\n- [x] AC-3: third (evidence: test.ts:2)",
+    );
+    const parsed = makeParsed("accepted", body, {
+      acceptance: [{ probe: "file-exists", path: "a.ts", criterion: "AC-1" }],
+    });
+    const violations = await runValidate(parsed);
+    const v35 = filterRule(violations, "V-35");
+    expect(v35).toHaveLength(0);
+  });
+
+  test("pre-cutoff probe without criterion does NOT fire V-35", async () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: test.ts:1)\n- [ ] AC-2: second\n- [x] AC-3: third (evidence: test.ts:2)",
+    );
+    const parsed = makeParsed("accepted", body, {
+      createdAt: "2026-01-01",
+      acceptance: [{ probe: "file-exists", path: "a.ts" }],
+    });
+    const violations = await runValidate(parsed);
+    const v35 = filterRule(violations, "V-35");
+    expect(v35).toHaveLength(0);
+  });
+});
+
+// ─── V-36: criterion identifier discipline ─────────────────────────────────
+
+describe("V-36: criterion identifier discipline (RFC-0997)", () => {
+  test("post-cutoff line without AC-N fires V-36", async () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: test.ts:1)\n- [ ] no id here\n- [x] AC-3: third (evidence: test.ts:2)",
+    );
+    const parsed = makeParsed("accepted", body);
+    const violations = await runValidate(parsed);
+    const v36 = filterRule(violations, "V-36");
+    expect(v36.length).toBeGreaterThanOrEqual(1);
+    expect(v36[0]!.message).toContain("lacks");
+  });
+
+  test("post-cutoff duplicate AC-N fires V-36", async () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: test.ts:1)\n- [ ] AC-1: dup\n- [x] AC-2: third (evidence: test.ts:2)",
+    );
+    const parsed = makeParsed("accepted", body);
+    const violations = await runValidate(parsed);
+    const v36 = filterRule(violations, "V-36");
+    expect(v36.length).toBeGreaterThanOrEqual(1);
+    expect(v36[0]!.message).toContain("duplicate");
+  });
+
+  test("pre-cutoff line without AC-N does NOT fire V-36", async () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: test.ts:1)\n- [ ] no id here\n- [x] AC-3: third (evidence: test.ts:2)",
+    );
+    const parsed = makeParsed("accepted", body, { createdAt: "2026-01-01" });
+    const violations = await runValidate(parsed);
+    const v36 = filterRule(violations, "V-36");
+    expect(v36).toHaveLength(0);
+  });
+});
+
+// ─── V-37: evidence mechanism validity ─────────────────────────────────────
+
+describe("V-37: evidence mechanism validity (RFC-0997)", () => {
+  test("post-cutoff probe:AC-N with no probe fires V-37", async () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: probe:AC-1)\n- [ ] AC-2: second\n- [x] AC-3: third (evidence: probe:AC-3)",
+    );
+    const parsed = makeParsed("accepted", body, {
+      acceptance: [],
+    });
+    const violations = await runValidate(parsed);
+    const v37 = filterRule(violations, "V-37");
+    expect(v37.length).toBeGreaterThanOrEqual(1);
+    expect(v37[0]!.message).toContain("no bound probe");
+  });
+
+  test("post-cutoff probe:AC-N referencing nonexistent criterion fires V-37", async () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: probe:AC-99)\n- [ ] AC-2: second\n- [x] AC-3: third (evidence: probe:AC-3)",
+    );
+    const parsed = makeParsed("accepted", body, {
+      acceptance: [],
+    });
+    const violations = await runValidate(parsed);
+    const v37 = filterRule(violations, "V-37");
+    expect(v37.length).toBeGreaterThanOrEqual(1);
+    expect(v37[0]!.message).toContain("does not exist");
+  });
+
+  test("post-cutoff test:path with missing file fires V-37", async () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: test:nonexistent/file.ts)\n- [ ] AC-2: second\n- [x] AC-3: third (evidence: test:nonexistent/file2.ts)",
+    );
+    const parsed = makeParsed("accepted", body, {
+      acceptance: [],
+    });
+    const violations = await runValidate(parsed);
+    const v37 = filterRule(violations, "V-37");
+    expect(v37.length).toBeGreaterThanOrEqual(1);
+    expect(v37[0]!.message).toContain("does not exist");
+  });
+
+  test("pre-cutoff does NOT fire V-37", async () => {
+    const body = BASE_BODY.replace(
+      "ACCEPTANCE_HERE",
+      "- [x] AC-1: first (evidence: probe:AC-99)\n- [ ] AC-2: second\n- [x] AC-3: third (evidence: probe:AC-99)",
+    );
+    const parsed = makeParsed("accepted", body, {
+      createdAt: "2026-01-01",
+      acceptance: [],
+    });
+    const violations = await runValidate(parsed);
+    const v37 = filterRule(violations, "V-37");
+    expect(v37).toHaveLength(0);
+  });
+});
+
+// ─── V-37: null-safety guard (no acceptance section) ───────────────────────
+
+describe("V-37: null-safety when no acceptance criteria section (RFC-0997)", () => {
+  test("post-cutoff RFC with no acceptance section does not crash", async () => {
+    const body = BASE_BODY.replace("## Acceptance criteria\n\nACCEPTANCE_HERE\n", "");
+    const parsed = makeParsed("accepted", body, {
+      acceptance: [{ probe: "file-exists", path: "a.ts", criterion: "AC-1" }],
+    });
+    const violations = await runValidate(parsed);
+    expect(violations).toBeDefined();
+  });
+});