@warpgogol/forge 2.8.0 → 2.8.2

package/src/tests/skill-schema.test.ts

@@ -0,0 +1,146 @@
+import { test, expect, describe } from "vitest";
+import { skillFrontmatterSchema } from "../skill-schema.ts";
+
+describe("skillFrontmatterSchema", () => {
+  const valid = {
+    name: "fo-idea",
+    description: "Analyze a user's idea and route to the appropriate pipeline.",
+    invocation: "user",
+    category: "fo",
+    concerns: "document-only",
+    dependsOn: ["my-preferences"],
+    languagePolicy: "ref(PREFERENCES.md)",
+  };
+
+  test("accepts a valid frontmatter", () => {
+    const result = skillFrontmatterSchema.safeParse(valid);
+    expect(result.success).toBe(true);
+  });
+
+  test("defaults dependsOn to empty array", () => {
+    const { dependsOn: _, ...withoutDeps } = valid;
+    const result = skillFrontmatterSchema.safeParse(withoutDeps);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.dependsOn).toEqual([]);
+    }
+  });
+
+  test("rejects empty name", () => {
+    expect(skillFrontmatterSchema.safeParse({ ...valid, name: "" }).success).toBe(false);
+  });
+
+  test("rejects empty description", () => {
+    expect(skillFrontmatterSchema.safeParse({ ...valid, description: "" }).success).toBe(false);
+  });
+
+  test("rejects description over 200 chars", () => {
+    expect(
+      skillFrontmatterSchema.safeParse({ ...valid, description: "x".repeat(201) }).success,
+    ).toBe(false);
+  });
+
+  test("accepts description of exactly 200 chars", () => {
+    expect(
+      skillFrontmatterSchema.safeParse({ ...valid, description: "x".repeat(200) }).success,
+    ).toBe(true);
+  });
+
+  test("rejects invalid invocation", () => {
+    expect(skillFrontmatterSchema.safeParse({ ...valid, invocation: "auto" }).success).toBe(false);
+  });
+
+  test("rejects invalid category", () => {
+    expect(skillFrontmatterSchema.safeParse({ ...valid, category: "other" }).success).toBe(false);
+  });
+
+  test("rejects invalid concerns", () => {
+    expect(skillFrontmatterSchema.safeParse({ ...valid, concerns: "hybrid" }).success).toBe(false);
+  });
+
+  test("rejects legacy implementation concerns value", () => {
+    expect(skillFrontmatterSchema.safeParse({ ...valid, concerns: "implementation" }).success).toBe(
+      false,
+    );
+  });
+
+  test("accepts read-only concerns", () => {
+    expect(skillFrontmatterSchema.safeParse({ ...valid, concerns: "read-only" }).success).toBe(
+      true,
+    );
+  });
+
+  test("accepts content-mutation concerns", () => {
+    expect(
+      skillFrontmatterSchema.safeParse({ ...valid, concerns: "content-mutation" }).success,
+    ).toBe(true);
+  });
+
+  test("accepts code-mutation concerns", () => {
+    expect(skillFrontmatterSchema.safeParse({ ...valid, concerns: "code-mutation" }).success).toBe(
+      true,
+    );
+  });
+
+  test("rejects invalid languagePolicy", () => {
+    expect(skillFrontmatterSchema.safeParse({ ...valid, languagePolicy: "en" }).success).toBe(
+      false,
+    );
+  });
+
+  test("accepts optional bindings field", () => {
+    const result = skillFrontmatterSchema.safeParse({
+      ...valid,
+      bindings: {
+        requires: ["commands.validateRfc"],
+        optional: ["paths.invariantsFile"],
+      },
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.bindings?.requires).toEqual(["commands.validateRfc"]);
+      expect(result.data.bindings?.optional).toEqual(["paths.invariantsFile"]);
+    }
+  });
+
+  test("accepts bindings with empty requires and optional", () => {
+    const result = skillFrontmatterSchema.safeParse({
+      ...valid,
+      bindings: { requires: [], optional: [] },
+    });
+    expect(result.success).toBe(true);
+  });
+
+  test("accepts frontmatter without bindings field", () => {
+    const result = skillFrontmatterSchema.safeParse(valid);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.bindings).toBeUndefined();
+    }
+  });
+
+  test("accepts optional knowledge field", () => {
+    const result = skillFrontmatterSchema.safeParse({
+      ...valid,
+      knowledge: ["qa-log.md", "learned-principles.md"],
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.knowledge).toEqual(["qa-log.md", "learned-principles.md"]);
+    }
+  });
+
+  test("accepts frontmatter without knowledge field", () => {
+    const result = skillFrontmatterSchema.safeParse(valid);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.knowledge).toBeUndefined();
+    }
+  });
+
+  test("rejects non-array knowledge", () => {
+    expect(skillFrontmatterSchema.safeParse({ ...valid, knowledge: "qa-log.md" }).success).toBe(
+      false,
+    );
+  });
+});

package/src/tests/skill-validate-knowledge.test.ts

@@ -0,0 +1,26 @@
+import { test, expect, describe } from "vitest";
+import { runSkillValidate } from "../validators/skill-validate.ts";
+
+describe("RFC-0660: SKILL-19/SKILL-20 validation", () => {
+  test("SKILL-19: zero violations on real workspace after migration", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const skill19Violations = result.violations.filter((v) => v.rule === "SKILL-19");
+    expect(skill19Violations).toEqual([]);
+  });
+
+  test("SKILL-20: zero violations on real workspace after migration", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const skill20Violations = result.violations.filter((v) => v.rule === "SKILL-20");
+    expect(skill20Violations).toEqual([]);
+  });
+
+  test("SKILL-19/SKILL-20: knowledge-adjacent files produce no violations", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const knowledgeViolations = result.violations.filter(
+      (v) => v.rule === "SKILL-19" || v.rule === "SKILL-20",
+    );
+    // forge-bootstrap has knowledge-adjacent files (forge-about.md, etc.)
+    // These should produce zero SKILL-19/SKILL-20 violations
+    expect(knowledgeViolations).toEqual([]);
+  });
+});

package/src/tests/skill-validate.test.ts

@@ -0,0 +1,254 @@
+import { test, expect, describe } from "vitest";
+import { runSkillValidate } from "../validators/skill-validate.ts";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+describe("SKILL-13: knowledge file existence", () => {
+  function createTempWorkspace(withKnowledgeFile: boolean): string {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "forge-skill13-"));
+    const forgeRoot = path.join(tmpDir, "packages", "forge");
+    const skillDir = path.join(forgeRoot, "skills", "fo", "test-skill");
+    fs.mkdirSync(skillDir, { recursive: true });
+
+    const skillMd = `---
+name: test-skill
+description: Test skill for SKILL-13 validation.
+invocation: user
+category: fo
+concerns: document-only
+dependsOn: []
+languagePolicy: ref(PREFERENCES.md)
+knowledge:
+  - qa-log.md
+---
+
+Before starting, read \`PREFERENCES.md\` at the repository root.
+`;
+    fs.writeFileSync(path.join(skillDir, "SKILL.md"), skillMd, "utf8");
+
+    if (withKnowledgeFile) {
+      fs.writeFileSync(path.join(skillDir, "qa-log.md"), "# Q&A Log\n", "utf8");
+    }
+
+    // Create a minimal registry that only includes the test skill
+    const registryDir = path.join(forgeRoot, "src");
+    fs.mkdirSync(registryDir, { recursive: true });
+
+    return tmpDir;
+  }
+
+  test("SKILL-13 passes when declared knowledge files exist", () => {
+    const tmpDir = createTempWorkspace(true);
+    try {
+      // runSkillValidate uses FORGE_SKILLS from registry.ts, not a temp registry.
+      // This test verifies the SKILL-13 logic path: if knowledge is declared and files exist, no SKILL-13 violation.
+      // Since we can't easily mock FORGE_SKILLS, we test the real skills instead.
+      const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+      const skill13Violations = result.violations.filter((v) => v.rule === "SKILL-13");
+      // fo-site-scan and grilling both have knowledge files that exist in the real workspace
+      expect(skill13Violations.length).toBe(0);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  test("SKILL-13 violation format", () => {
+    // Verify that the real workspace has no SKILL-13 violations (all declared knowledge files exist)
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const skill13Violations = result.violations.filter((v) => v.rule === "SKILL-13");
+    expect(skill13Violations).toEqual([]);
+  });
+});
+
+describe("RFC-0539: Pack skill validation (SKILL-14, SKILL-15)", () => {
+  test("SKILL-14 and SKILL-15: real workspace pack skills have correct prefix and no fo- prefix", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const skill14Violations = result.violations.filter((v) => v.rule === "SKILL-14");
+    const skill15Violations = result.violations.filter((v) => v.rule === "SKILL-15");
+    expect(skill14Violations).toEqual([]);
+    expect(skill15Violations).toEqual([]);
+  });
+
+  test("SKILL-07: no forge skill depends on a pack skill (asymmetric direction)", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const skill07Violations = result.violations.filter((v) => v.rule === "SKILL-07");
+    // No forge skill should have a dependsOn referencing a pack skill
+    expect(skill07Violations).toEqual([]);
+  });
+});
+
+describe("RFC-0548: SKILL-16 triggers field validation", () => {
+  test("SKILL-16: real workspace fo-skills have valid triggers (no violations)", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const skill16Violations = result.violations.filter((v) => v.rule === "SKILL-16");
+    expect(skill16Violations).toEqual([]);
+  });
+
+  test("SKILL-16: triggers are only on fo-category skills", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const skill16Violations = result.violations.filter(
+      (v) => v.rule === "SKILL-16" && v.message.includes("only allowed on fo-category"),
+    );
+    expect(skill16Violations).toEqual([]);
+  });
+
+  test("SKILL-16: no pack skills declare triggers", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const packTriggerViolations = result.violations.filter(
+      (v) => v.rule === "SKILL-16" && v.message.includes("pack skills may not declare triggers"),
+    );
+    expect(packTriggerViolations).toEqual([]);
+  });
+});
+
+describe("RFC-0553: SKILL-17 platform reference prohibition", () => {
+  test("SKILL-17: real workspace has no platform RFC/ADR/DNA id violations after cleanup", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const skill17IdViolations = result.violations.filter(
+      (v) => v.rule === "SKILL-17" && v.message.includes("RFC/ADR/DNA id"),
+    );
+    expect(skill17IdViolations).toEqual([]);
+  });
+
+  test("SKILL-17: real workspace has no platform name violations after cleanup", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const skill17NameViolations = result.violations.filter(
+      (v) => v.rule === "SKILL-17" && v.message.includes("platform name"),
+    );
+    expect(skill17NameViolations).toEqual([]);
+  });
+
+  test("SKILL-17: RFC-\\\\d{4} pattern does not match bare RFC or ADR without digits", () => {
+    const rfcPattern = /\bRFC-\d{4}\b/g;
+    const adrPattern = /\bADR-\d{4}\b/g;
+    const dnaRe = () => new RegExp("\\bDNA-\\d+\\b", "g");
+    expect(rfcPattern.test("This skill audits RFCs")).toBe(false);
+    expect(rfcPattern.test("Create a new ADR")).toBe(false);
+    expect(rfcPattern.test("RFC-XXXX")).toBe(false);
+    expect(rfcPattern.test("RFC-0353")).toBe(true);
+    expect(adrPattern.test("ADR-0003")).toBe(true);
+    expect(dnaRe().test("DNA-42")).toBe(true);
+    expect(dnaRe().test("DNA-1")).toBe(true);
+    expect(dnaRe().test("DNA-N")).toBe(false);
+    expect(dnaRe().test("DNA-<N>")).toBe(false);
+    expect(dnaRe().test("DNA-NN")).toBe(false);
+    expect(dnaRe().test("DNA candidate")).toBe(false);
+  });
+
+  test("SKILL-17: pattern does not match lowercase file paths", () => {
+    const idPattern = /\bADR-\d{4}\b/g;
+    expect(idPattern.test("adr-0000-template.md")).toBe(false);
+    expect(idPattern.test("rfc-0000-template.md")).toBe(false);
+  });
+
+  test("SKILL-17: @warpgogol npm scope is not a platform name violation (regression 2026-08-03)", () => {
+    // Mirrors SKILL17_PLATFORM_PATTERNS in skill-validate.ts. The brand pattern
+    // must stay case-sensitive — with /gi it defeated the first pattern's
+    // @-lookbehind and false-flagged every `@warpgogol/<pkg>` reference.
+    const platformPatterns = [/(?<!@)Warpgogol\b/gi, /\bWarpGogol\b/g];
+    const matches = (line: string) =>
+      platformPatterns.some((p) => new RegExp(p.source, p.flags).test(line));
+    expect(matches("Read the template inside `@warpgogol/forge`")).toBe(false);
+    expect(matches("- No imports from `@warpgogol/site-kernel`.")).toBe(false);
+    expect(matches("The Warpgogol platform requires this")).toBe(true);
+    expect(matches("WarpGogol brand mention")).toBe(true);
+  });
+});
+
+describe("RFC-0642: SKILL-18 domain-specific binding key prohibition", () => {
+  test("SKILL-18: real workspace has no SKILL-18 violations after migration", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const skill18Violations = result.violations.filter((v) => v.rule === "SKILL-18");
+    expect(skill18Violations).toEqual([]);
+  });
+
+  test("SKILL-18: pattern matches software-specific binding keys", () => {
+    const patterns = [
+      /bindings\.commands\.typecheck/gi,
+      /bindings\.commands\.scopedBuild/gi,
+      /bindings\.commands\.test/gi,
+    ];
+    const softwareSpecific = [
+      "ref(forge.yaml bindings.commands.typecheck)",
+      "ref(forge.yaml bindings.commands.scopedBuild)",
+      "ref(forge.yaml bindings.commands.test)",
+    ];
+    const semanticKeys = [
+      "ref(forge.yaml bindings.commands.validate)",
+      "ref(forge.yaml bindings.commands.produce)",
+      "ref(forge.yaml bindings.commands.verify)",
+    ];
+    for (const text of softwareSpecific) {
+      expect(patterns.some((p) => new RegExp(p.source, p.flags).test(text))).toBe(true);
+    }
+    for (const text of semanticKeys) {
+      expect(patterns.some((p) => new RegExp(p.source, p.flags).test(text))).toBe(false);
+    }
+  });
+
+  test("SKILL-18: escape hatch suppresses violation", () => {
+    const skill18Patterns = [
+      /bindings\.commands\.typecheck/gi,
+      /bindings\.commands\.scopedBuild/gi,
+      /bindings\.commands\.test/gi,
+    ];
+    const disableMarker = "<!-- skill-lint-disable SKILL-18 -->";
+    const bodyWithEscapeHatch = `${disableMarker}\n\n\`\`\`sh\nref(forge.yaml bindings.commands.typecheck)\n\`\`\``;
+    const bodyWithoutEscapeHatch = `\`\`\`sh\nref(forge.yaml bindings.commands.typecheck)\n\`\`\``;
+
+    // With escape hatch: no violation
+    expect(bodyWithEscapeHatch.includes(disableMarker)).toBe(true);
+
+    // Without escape hatch: pattern matches
+    const instructionLines = bodyWithoutEscapeHatch
+      .split(/\r?\n/)
+      .filter((line) => line.trim().startsWith("ref("));
+    expect(
+      instructionLines.some((line) =>
+        skill18Patterns.some((p) => new RegExp(p.source, p.flags).test(line)),
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("SKILL-21: knowledge layer token budget warnings (RFC-0661)", () => {
+  test("SkillValidateResult has warnings array", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    expect(result).toHaveProperty("warnings");
+    expect(Array.isArray(result.warnings)).toBe(true);
+  });
+
+  test("warnings never affect status — pass even with warnings", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    // If there are any warnings, status should still be "pass" (warnings are not errors)
+    if (result.warnings.length > 0) {
+      expect(result.status).toBe("pass");
+    }
+    // Violations should only contain errors, not warnings
+    const warningRulesInViolations = result.violations.filter((v) => v.severity === "warning");
+    expect(warningRulesInViolations).toEqual([]);
+  });
+
+  test("SKILL-19 legacy-section warnings are in warnings, not violations", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    // Any SKILL-19 warnings should be in warnings array, not violations
+    const skill19InViolations = result.violations.filter(
+      (v) => v.rule === "SKILL-19" && v.severity === "warning",
+    );
+    expect(skill19InViolations).toEqual([]);
+    // SKILL-19 errors (schema issues) should still be in violations
+    const skill19Errors = result.violations.filter(
+      (v) => v.rule === "SKILL-19" && v.severity === "error",
+    );
+    // There should be no schema errors in current workspace
+    expect(skill19Errors).toEqual([]);
+  });
+
+  test("no SKILL-21 warnings at introduction — all forge skills within default budgets", () => {
+    const result = runSkillValidate({}, { workspaceRoot: process.cwd() });
+    const skill21Warnings = result.warnings.filter((w) => w.rule === "SKILL-21");
+    // All existing knowledge files are knowledge-adjacent (freeform), so no budget warnings
+    expect(skill21Warnings).toEqual([]);
+  });
+});

package/src/tests/stack-profile.test.ts

@@ -0,0 +1,221 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Unit tests for stack profile schema, loader, and detector.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0392: initial stack profile tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  stackProfileSchema,
+  loadStackProfile,
+  listStackProfiles,
+  detectStack,
+  type StackProfile,
+} from "../profiles/stack-profile.ts";
+
+// Resolve forge root from this test file's location
+const FORGE_ROOT = join(import.meta.dirname, "..", "..");
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "stack-profile-test-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+const validProfile: StackProfile = {
+  schema: "forge/stack-profile@1",
+  id: "test-profile",
+  displayName: "Test Profile",
+  detect: { anyOf: ["astro.config.*", "tsconfig.json"] },
+  workspace: {
+    dirs: ["sites", "packages"],
+    files: [{ path: "pnpm-workspace.yaml", content: "packages:\n  - sites/*\n  - packages/*" }],
+  },
+  install: ["pnpm add -D typescript"],
+};
+
+test("stackProfileSchema validates a valid profile", () => {
+  const result = stackProfileSchema.safeParse(validProfile);
+  expect(result.success).toBe(true);
+});
+
+test("stackProfileSchema rejects missing schema field", () => {
+  const bad = { ...validProfile, schema: "wrong" };
+  const result = stackProfileSchema.safeParse(bad);
+  expect(result.success).toBe(false);
+});
+
+test("stackProfileSchema rejects empty detect.anyOf", () => {
+  const bad = { ...validProfile, detect: { anyOf: [] } };
+  const result = stackProfileSchema.safeParse(bad);
+  expect(result.success).toBe(false);
+});
+
+test("loadStackProfile parses valid YAML", async () => {
+  const yaml = `
+schema: forge/stack-profile@1
+id: my-profile
+displayName: My Profile
+detect:
+  anyOf: ["package.json"]
+workspace:
+  dirs: ["src"]
+  files:
+    - path: package.json
+      content: "{}"
+install: []
+`;
+  const profilePath = join(tempDir, "test.yaml");
+  await writeFile(profilePath, yaml, "utf8");
+  const profile = loadStackProfile(profilePath);
+  expect(profile.id).toBe("my-profile");
+  expect(profile.workspace.dirs).toEqual(["src"]);
+});
+
+test("loadStackProfile throws on invalid YAML", async () => {
+  const yaml = `schema: forge/stack-profile@1\nid: ""`;
+  const profilePath = join(tempDir, "bad.yaml");
+  await writeFile(profilePath, yaml, "utf8");
+  expect(() => loadStackProfile(profilePath)).toThrow("failed schema validation");
+});
+
+test("listStackProfiles loads all YAML files from profiles dir", async () => {
+  const profilesDir = join(tempDir, "profiles");
+  await mkdir(profilesDir, { recursive: true });
+  await writeFile(
+    join(profilesDir, "a.yaml"),
+    `schema: forge/stack-profile@1\nid: a\ndisplayName: A\ndetect:\n  anyOf: ["a.txt"]\nworkspace:\n  dirs: ["src"]\n  files: []\ninstall: []`,
+    "utf8",
+  );
+  await writeFile(
+    join(profilesDir, "b.yaml"),
+    `schema: forge/stack-profile@1\nid: b\ndisplayName: B\ndetect:\n  anyOf: ["b.txt"]\nworkspace:\n  dirs: ["src"]\n  files: []\ninstall: []`,
+    "utf8",
+  );
+  const profiles = listStackProfiles(tempDir);
+  expect(profiles.length).toBe(2);
+  expect(profiles.map((p) => p.id).sort()).toEqual(["a", "b"]);
+});
+
+test("listStackProfiles returns empty array when profiles dir missing", () => {
+  const profiles = listStackProfiles(tempDir);
+  expect(profiles).toEqual([]);
+});
+
+test("detectStack matches on anyOf glob", async () => {
+  await writeFile(join(tempDir, "astro.config.mjs"), "export default {}", "utf8");
+  const profiles: StackProfile[] = [
+    { ...validProfile, id: "astro", detect: { anyOf: ["astro.config.*"] } },
+    { ...validProfile, id: "phaser", detect: { anyOf: ["phaser.config.*"] } },
+  ];
+  const match = detectStack(tempDir, profiles);
+  expect(match?.id).toBe("astro");
+});
+
+test("detectStack returns null when no pattern matches", async () => {
+  const profiles: StackProfile[] = [
+    { ...validProfile, id: "rust", detect: { anyOf: ["Cargo.toml"] } },
+  ];
+  const match = detectStack(tempDir, profiles);
+  expect(match).toBeNull();
+});
+
+test("detectStack matches on exact filename", async () => {
+  await writeFile(join(tempDir, "tsconfig.json"), "{}", "utf8");
+  const profiles: StackProfile[] = [
+    { ...validProfile, id: "ts", detect: { anyOf: ["tsconfig.json"] } },
+  ];
+  const match = detectStack(tempDir, profiles);
+  expect(match?.id).toBe("ts");
+});
+
+test("shipped phaser-turborepo profile validates", () => {
+  const profile = loadStackProfile(join(FORGE_ROOT, "profiles", "phaser-turborepo.yaml"));
+  expect(profile.id).toBe("phaser-turborepo");
+  expect(profile.workspace.dirs.length).toBeGreaterThan(0);
+});
+
+test("shipped godot-csharp profile validates", () => {
+  const profile = loadStackProfile(join(FORGE_ROOT, "profiles", "godot-csharp.yaml"));
+  expect(profile.id).toBe("godot-csharp");
+  expect(profile.workspace.dirs.length).toBeGreaterThan(0);
+});
+
+test("listStackProfiles finds all shipped profiles", () => {
+  const profiles = listStackProfiles(FORGE_ROOT);
+  const ids = profiles.map((p) => p.id).sort();
+  expect(ids).toContain("phaser-turborepo");
+  expect(ids).toContain("godot-csharp");
+  expect(ids).toContain("forge-shell");
+});
+
+test("all shipped profiles include @warpgogol/forge in install steps or package.json template", () => {
+  const profiles = listStackProfiles(FORGE_ROOT);
+  for (const profile of profiles) {
+    // knowledge-typescript-turborepo uses @warpgogol/werkstatt-knowledge plugin, not forge
+    if (profile.id === "knowledge-typescript-turborepo") continue;
+    const hasForgeInInstall = profile.install.some((cmd) => cmd.includes("@warpgogol/forge"));
+    const pkgFile = profile.workspace.files.find((f) => f.path === "package.json");
+    const hasForgeInPkg = pkgFile?.content.includes("@warpgogol/forge") ?? false;
+    expect(hasForgeInInstall || hasForgeInPkg, `profile ${profile.id}`).toBe(true);
+  }
+});
+
+test("all shipped profiles include operator-profile.md in .gitignore content", () => {
+  const profiles = listStackProfiles(FORGE_ROOT);
+  for (const profile of profiles) {
+    // knowledge-typescript-turborepo uses a different plugin and gitignore template
+    if (profile.id === "knowledge-typescript-turborepo") continue;
+    const gitignoreFile = profile.workspace.files.find((f) => f.path === ".gitignore");
+    expect(gitignoreFile).toBeDefined();
+    expect(gitignoreFile?.content).toContain("operator-profile.md");
+  }
+});
+
+test("stackProfileSchema accepts optional scriptDir field (ADR-0043)", () => {
+  const withScriptDir = { ...validProfile, scriptDir: "tools/scripts" };
+  const result = stackProfileSchema.safeParse(withScriptDir);
+  expect(result.success).toBe(true);
+  expect((result.data as StackProfile).scriptDir).toBe("tools/scripts");
+});
+
+test("stackProfileSchema accepts profile without scriptDir (defaults to scripts/)", () => {
+  const result = stackProfileSchema.safeParse(validProfile);
+  expect(result.success).toBe(true);
+  expect((result.data as StackProfile).scriptDir).toBeUndefined();
+});
+
+test("stackProfileSchema rejects empty scriptDir string", () => {
+  const bad = { ...validProfile, scriptDir: "" };
+  const result = stackProfileSchema.safeParse(bad);
+  expect(result.success).toBe(false);
+});
+
+test("RFC-0854: all shipped profiles with package.json template declare engines.node >=24 <25", () => {
+  const profiles = listStackProfiles(FORGE_ROOT);
+  for (const profile of profiles) {
+    const pkgFile = profile.workspace.files.find((f) => f.path === "package.json");
+    if (!pkgFile) continue;
+    if (!pkgFile.content.includes("engines")) continue;
+    expect(pkgFile.content, `profile ${profile.id} package.json`).toContain(">=24 <25");
+  }
+});
+
+test("RFC-0854: all shipped profiles with CI workflow declare node-version: 24", () => {
+  const profiles = listStackProfiles(FORGE_ROOT);
+  for (const profile of profiles) {
+    const ciFile = profile.workspace.files.find((f) => f.path === ".github/workflows/ci.yml");
+    if (!ciFile) continue;
+    expect(ciFile.content, `profile ${profile.id} CI workflow`).toContain('node-version: "24"');
+  }
+});

package/src/tests/string-utils.test.ts

@@ -0,0 +1,42 @@
+import { test, expect, describe } from "vitest";
+import { toKebabCase } from "../utils/string-utils.ts";
+
+describe("toKebabCase", () => {
+  test("lowercases simple input", () => {
+    expect(toKebabCase("Hello")).toBe("hello");
+  });
+
+  test("replaces spaces with hyphens", () => {
+    expect(toKebabCase("hello world")).toBe("hello-world");
+  });
+
+  test("replaces non-alphanumeric with hyphens", () => {
+    expect(toKebabCase("hello_world")).toBe("hello-world");
+    expect(toKebabCase("hello.world")).toBe("hello-world");
+    expect(toKebabCase("hello@world!")).toBe("hello-world");
+  });
+
+  test("strips leading/trailing hyphens", () => {
+    expect(toKebabCase("--hello--")).toBe("hello");
+    expect(toKebabCase("  hello  ")).toBe("hello");
+  });
+
+  test("collapses multiple separators", () => {
+    expect(toKebabCase("hello   world")).toBe("hello-world");
+    expect(toKebabCase("hello___world")).toBe("hello-world");
+  });
+
+  test("empty string stays empty", () => {
+    expect(toKebabCase("")).toBe("");
+  });
+
+  test("all-symbols string becomes empty", () => {
+    expect(toKebabCase("---")).toBe("");
+    expect(toKebabCase("@#$%")).toBe("");
+  });
+
+  test("preserves digits", () => {
+    expect(toKebabCase("hello123")).toBe("hello123");
+    expect(toKebabCase("hello 123 world")).toBe("hello-123-world");
+  });
+});