@warpgogol/forge 2.21.5 → 2.21.7

package/os/core/handlers/validate.ts

@@ -3,12 +3,13 @@
 <purpose>forge.validate — execute validate commands for all artifacts declared in the active stack profile. Supports --dry-run, --json, --artifact filtering, and violation parsing.</purpose>
 <non-goals>
   <item>Do not implement dev or build logic — those are separate handlers.</item>
-  <item>Do not import from @warpgogol/* — this module is portable.</item>
+  <item>Do not import from @warpgogol/* — compass handler is intra-package within @warpgogol/forge.</item>
 </non-goals>
 </MODULE_CONTRACT>
 <CHANGE_SUMMARY>
   <item>RFC-0674: initial forge.validate handler with profile resolution, --dry-run, and per-artifact execution.</item>
   <item>RFC-0677: extended with --artifact filtering, violation parsing (outputFormat: json/plain), passed/allPassed fields.</item>
+  <item>Integrated compass.validate as in-process step after artifact validations for automatic Compass enforcement.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -20,6 +21,7 @@ import type {
   ForgeRuntimeContext,
 } from "../../../src/types.ts";
 import { resolveActiveProfile, resolveLifecycleFlags } from "./profile-resolve.ts";
+import { runCompassValidation } from "../../compass/handlers/compass-inventory-handler.ts";
 
 const execAsync = promisify(exec);
 
@@ -41,11 +43,25 @@ export interface ForgeValidateArtifactResult {
   stderr: string;
 }
 
+export interface ForgeValidateCompassResult {
+  passed: boolean;
+  checkedFiles: number;
+  failures: number;
+  diagnostics: Array<{
+    ruleId: string;
+    severity: string;
+    file: string;
+    message: string;
+    fix: string;
+  }>;
+}
+
 export interface ForgeValidateResult {
   command: "forge.validate";
   profileId: string;
   artifacts: ForgeValidateArtifactResult[];
   allPassed: boolean;
+  compass?: ForgeValidateCompassResult;
 }
 
 export function parseViolations(
@@ -185,6 +201,12 @@ export async function runValidate(
           stderr: "",
         })),
         allPassed: true,
+        compass: {
+          passed: true,
+          checkedFiles: 0,
+          failures: 0,
+          diagnostics: [],
+        },
       },
       summary: `[dry-run] ${commands.length} validate command(s) resolved`,
     };
@@ -245,7 +267,37 @@ export async function runValidate(
     }
   }
 
-  const allPassed = results.every((r) => r.passed);
+  const artifactsAllPassed = results.every((r) => r.passed);
+
+  let compassResult: ForgeValidateCompassResult | undefined;
+  try {
+    const compassResponse = await runCompassValidation({ argv: [], flags: {} }, context);
+    if (compassResponse.data) {
+      compassResult = {
+        passed: (compassResponse.exitCode ?? 0) === 0,
+        checkedFiles: compassResponse.data.checkedFiles,
+        failures: compassResponse.data.failures,
+        diagnostics: compassResponse.data.diagnostics,
+      };
+    }
+  } catch {
+    // compass.validate not available in this workspace — skip
+  }
+
+  const allPassed = artifactsAllPassed && (compassResult?.passed ?? true);
+
+  const summaryParts: string[] = [
+    allPassed
+      ? `forge.validate: all ${results.length} artifact(s) passed`
+      : `forge.validate: ${results.filter((r) => !r.passed).length} artifact(s) failed`,
+  ];
+  if (compassResult) {
+    summaryParts.push(
+      compassResult.passed
+        ? `compass: OK (${compassResult.checkedFiles} files)`
+        : `compass: ${compassResult.failures} failure(s)`,
+    );
+  }
 
   return {
     data: {
@@ -253,10 +305,9 @@ export async function runValidate(
       profileId: profile.id,
       artifacts: results,
       allPassed,
+      compass: compassResult,
     },
     exitCode: allPassed ? 0 : 1,
-    summary: allPassed
-      ? `forge.validate: all ${results.length} artifact(s) passed`
-      : `forge.validate: ${results.filter((r) => !r.passed).length} artifact(s) failed`,
+    summary: summaryParts.join("; "),
   };
 }

package/os/naming/naming-convention.ts

@@ -63,6 +63,12 @@ const NAMING_CONVENTION_IGNORED_TOP_LEVEL = new Set([
   ".windsurf",
   ".cache",
   "tmp",
+  ".adr-locks",
+  ".rfc-locks",
+  ".devin",
+  ".forge",
+  "patches",
+  "storage",
 ]);
 
 // Tool-mandated filenames exempt from kebab-case (Docker, Caddy use these exact names).
@@ -93,6 +99,9 @@ const NAMING_CONVENTION_EXEMPT_KEYWORDS = ["config", "module"] as const;
 // Set of directory paths that are exempt from naming convention (generated files)
 const NAMING_CONVENTION_EXEMPT_DIRS = new Set([
   "components/icons/gen", // Generated icon components — naming controlled by generator
+  "docs/performance", // Tool-generated screenshots and Lighthouse reports with timestamps
+  "docs/specs", // Imported specification documents with their own naming convention
+  "docs/rfcs/archive", // Archived RFCs — historical artifacts, cannot be renamed
 ]);
 
 /**

package/os/plugin/plugin.module.ts

@@ -21,7 +21,7 @@ import type {
   ForgeRuntimeContext,
 } from "../../src/types.ts";
 import { loadForgeConfig } from "../../src/config/forge-config.ts";
-import { forgePluginManifestSchema } from "../../src/plugin/ForgePluginManifest.ts";
+import { forgePluginManifestSchema } from "../../src/plugin/forge-plugin-manifest.ts";
 
 export interface PluginValidateResult {
   command: "forge.plugin.validate";

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);