@warpgogol/forge 2.8.0 → 2.8.2

package/src/tests/package-files.test.ts

@@ -0,0 +1,54 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Verify that template files referenced by source code are included in the npm package
+(files array in package.json). Prevents shipping bugs where template files exist on disk
+but are missing from the published package.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>Initial test: verify onboarding templates are in package.json files array.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect } from "vitest";
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+const PACKAGE_ROOT = join(import.meta.dirname, "..", "..");
+
+function readPackageFiles(): string[] {
+  const pkg = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8")) as {
+    files?: string[];
+  };
+  return pkg.files ?? [];
+}
+
+test("package.json files array includes src/onboarding/templates/", () => {
+  const files = readPackageFiles();
+  const hasTemplates = files.some(
+    (f) => f === "src/onboarding/templates/" || f === "src/onboarding/templates/*" || f === "src/",
+  );
+  expect(hasTemplates).toBe(true);
+});
+
+test("all template files in src/onboarding/templates/ are covered by files array", () => {
+  const files = readPackageFiles();
+  const hasTemplatesGlob = files.some(
+    (f) => f === "src/onboarding/templates/" || f === "src/onboarding/templates/*" || f === "src/",
+  );
+  expect(hasTemplatesGlob).toBe(true);
+});
+
+test("root AGENTS.md templates exist and are readable", () => {
+  const templatesDir = join(PACKAGE_ROOT, "src", "onboarding", "templates");
+
+  const templateFiles = readdirSync(templatesDir);
+  expect(templateFiles).toContain("root-agents-business.md");
+  expect(templateFiles).toContain("root-agents-creative.md");
+  expect(templateFiles).toContain("behavioral-layer-core.md");
+  expect(templateFiles).toContain("behavioral-layer-extended.md");
+
+  for (const file of templateFiles) {
+    const content = readFileSync(join(templatesDir, file), "utf8");
+    expect(content.length).toBeGreaterThan(0);
+  }
+});

package/src/tests/pinned-check.test.ts

@@ -0,0 +1,194 @@
+import { test, expect, describe } from "vitest";
+import { mkdtemp, rm, mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  loadPinnedManifest,
+  isPinned,
+  isIntraDirMove,
+  checkFilesForPinned,
+  PinnedManifestMalformedError,
+} from "../../os/core/handlers/pinned-check.ts";
+import type { PinnedManifest } from "../../os/core/handlers/pinned-types.ts";
+
+async function makeTempDir(): Promise<string> {
+  return mkdtemp(join(tmpdir(), "forge-pinned-test-"));
+}
+
+describe("loadPinnedManifest", () => {
+  test("returns null when manifest does not exist", async () => {
+    const dir = await makeTempDir();
+    try {
+      const result = await loadPinnedManifest(dir);
+      expect(result).toBeNull();
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("loads valid manifest with entries", async () => {
+    const dir = await makeTempDir();
+    try {
+      await mkdir(join(dir, ".forge"), { recursive: true });
+      await writeFile(
+        join(dir, ".forge", "pinned.yaml"),
+        "pinned:\n  - path: docs/rfcs/rfc-0000-template.md\n    mode: freeze\n    reason: RFC template\n  - path: forge.yaml\n    mode: protect\n    reason: Forge config\n",
+      );
+      const result = await loadPinnedManifest(dir);
+      expect(result).not.toBeNull();
+      expect(result!.pinned).toHaveLength(2);
+      expect(result!.pinned[0]!.path).toBe("docs/rfcs/rfc-0000-template.md");
+      expect(result!.pinned[0]!.mode).toBe("freeze");
+      expect(result!.pinned[1]!.path).toBe("forge.yaml");
+      expect(result!.pinned[1]!.mode).toBe("protect");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("throws PinnedManifestMalformedError for invalid YAML", async () => {
+    const dir = await makeTempDir();
+    try {
+      await mkdir(join(dir, ".forge"), { recursive: true });
+      await writeFile(join(dir, ".forge", "pinned.yaml"), "pinned: [invalid yaml {{{");
+      await expect(loadPinnedManifest(dir)).rejects.toThrow(PinnedManifestMalformedError);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("throws PinnedManifestMalformedError when pinned array is missing", async () => {
+    const dir = await makeTempDir();
+    try {
+      await mkdir(join(dir, ".forge"), { recursive: true });
+      await writeFile(join(dir, ".forge", "pinned.yaml"), "foo: bar\n");
+      await expect(loadPinnedManifest(dir)).rejects.toThrow(PinnedManifestMalformedError);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("throws PinnedManifestMalformedError for invalid mode", async () => {
+    const dir = await makeTempDir();
+    try {
+      await mkdir(join(dir, ".forge"), { recursive: true });
+      await writeFile(
+        join(dir, ".forge", "pinned.yaml"),
+        "pinned:\n  - path: foo.md\n    mode: invalid\n    reason: test\n",
+      );
+      await expect(loadPinnedManifest(dir)).rejects.toThrow(PinnedManifestMalformedError);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("isPinned", () => {
+  const manifest: PinnedManifest = {
+    pinned: [
+      { path: "docs/rfcs/rfc-0000-template.md", mode: "freeze", reason: "template" },
+      { path: "docs/rfcs/", mode: "protect", reason: "RFC directory" },
+    ],
+  };
+
+  test("exact match returns entry", () => {
+    const entry = isPinned(manifest, "docs/rfcs/rfc-0000-template.md");
+    expect(entry).not.toBeNull();
+    expect(entry!.mode).toBe("freeze");
+  });
+
+  test("directory prefix match returns entry", () => {
+    const entry = isPinned(manifest, "docs/rfcs/rfc-0733.md");
+    expect(entry).not.toBeNull();
+    expect(entry!.mode).toBe("protect");
+  });
+
+  test("non-matching path returns null", () => {
+    const entry = isPinned(manifest, "docs/adrs/adr-0001.md");
+    expect(entry).toBeNull();
+  });
+
+  test("path outside directory prefix does not match", () => {
+    const entry = isPinned(manifest, "docs/rfcs-archive/old.md");
+    expect(entry).toBeNull();
+  });
+});
+
+describe("checkFilesForPinned", () => {
+  const manifest: PinnedManifest = {
+    pinned: [
+      { path: "docs/rfcs/rfc-0000-template.md", mode: "freeze", reason: "template" },
+      { path: "docs/rfcs/", mode: "protect", reason: "RFC directory" },
+    ],
+  };
+
+  test("returns violations for pinned files", () => {
+    const violations = checkFilesForPinned(manifest, [
+      { relPath: "docs/rfcs/rfc-0000-template.md", operation: "delete" },
+      { relPath: "docs/adrs/adr-0001.md", operation: "move" },
+    ]);
+    expect(violations).toHaveLength(1);
+    expect(violations[0]!.path).toBe("docs/rfcs/rfc-0000-template.md");
+    expect(violations[0]!.operation).toBe("delete");
+  });
+
+  test("returns empty array when no files are pinned", () => {
+    const violations = checkFilesForPinned(manifest, [
+      { relPath: "docs/adrs/adr-0001.md", operation: "move" },
+      { relPath: "README.md", operation: "modify" },
+    ]);
+    expect(violations).toHaveLength(0);
+  });
+});
+
+describe("isIntraDirMove", () => {
+  const manifest: PinnedManifest = {
+    pinned: [
+      { path: "docs/rfcs/rfc-0000-template.md", mode: "freeze", reason: "template" },
+      { path: "docs/rfcs/", mode: "protect", reason: "RFC directory" },
+      { path: "docs/adrs/", mode: "protect", reason: "ADR directory" },
+    ],
+  };
+
+  test("returns true when both source and dest are inside the same pinned dir", () => {
+    expect(
+      isIntraDirMove(
+        manifest,
+        "docs/rfcs/rfc-0076.md",
+        "docs/rfcs/archive/implemented/rfc-0076.md",
+      ),
+    ).toBe(true);
+  });
+
+  test("returns true for reverse move (archive → active)", () => {
+    expect(
+      isIntraDirMove(
+        manifest,
+        "docs/rfcs/archive/implemented/rfc-0076.md",
+        "docs/rfcs/rfc-0076.md",
+      ),
+    ).toBe(true);
+  });
+
+  test("returns false when dest is outside the pinned dir", () => {
+    expect(isIntraDirMove(manifest, "docs/rfcs/rfc-0076.md", "docs/other/rfc-0076.md")).toBe(false);
+  });
+
+  test("returns false when source is not in any pinned dir", () => {
+    expect(isIntraDirMove(manifest, "README.md", "docs/rfcs/README.md")).toBe(false);
+  });
+
+  test("returns false for file-pinned entries (not directory-pinned)", () => {
+    expect(
+      isIntraDirMove(
+        manifest,
+        "docs/rfcs/rfc-0000-template.md",
+        "docs/rfcs/archive/rfc-0000-template.md",
+      ),
+    ).toBe(true);
+  });
+
+  test("returns false when source and dest are in different pinned dirs", () => {
+    expect(isIntraDirMove(manifest, "docs/rfcs/rfc-0076.md", "docs/adrs/adr-0001.md")).toBe(false);
+  });
+});

package/src/tests/pinned-init.test.ts

@@ -0,0 +1,126 @@
+import { test, expect, describe } from "vitest";
+import { mkdtemp, rm, mkdir, writeFile, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { runPinnedInit, DEFAULT_PINNED_ENTRIES } from "../../os/core/handlers/pinned-init.ts";
+import type { ForgeCommandInput, ForgeRuntimeContext, ForgeFlagValue } from "../../src/types.ts";
+
+async function makeTempDir(): Promise<string> {
+  return mkdtemp(join(tmpdir(), "forge-pinned-init-test-"));
+}
+
+function makeContext(workspaceRoot: string): ForgeRuntimeContext {
+  return {
+    workspaceRoot,
+    logger: {
+      section: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      success: () => {},
+    },
+    dryRun: false,
+    outputFormat: "json",
+  };
+}
+
+function makeInput(flags: Record<string, ForgeFlagValue> = {}): ForgeCommandInput {
+  return { argv: [], flags };
+}
+
+describe("runPinnedInit", () => {
+  test("creates manifest with default entries", async () => {
+    const dir = await makeTempDir();
+    try {
+      const result = await runPinnedInit(makeInput(), makeContext(dir));
+      expect(result.data?.status).toBe("ok");
+      expect(result.data?.manifestAction).toBe("created");
+      expect(result.data?.entriesCount).toBe(DEFAULT_PINNED_ENTRIES.length);
+
+      const manifestExists = existsSync(join(dir, ".forge", "pinned.yaml"));
+      expect(manifestExists).toBe(true);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("creates .gitignore with audit log entry", async () => {
+    const dir = await makeTempDir();
+    try {
+      await runPinnedInit(makeInput(), makeContext(dir));
+      const gitignoreContent = await readFile(join(dir, ".gitignore"), "utf8");
+      expect(gitignoreContent).toContain(".forge/pinned-audit.log");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("appends audit log to existing .gitignore", async () => {
+    const dir = await makeTempDir();
+    try {
+      await writeFile(join(dir, ".gitignore"), "node_modules/\ndist/\n");
+      await runPinnedInit(makeInput(), makeContext(dir));
+      const gitignoreContent = await readFile(join(dir, ".gitignore"), "utf8");
+      expect(gitignoreContent).toContain("node_modules/");
+      expect(gitignoreContent).toContain(".forge/pinned-audit.log");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("does not duplicate audit log entry on re-run", async () => {
+    const dir = await makeTempDir();
+    try {
+      await runPinnedInit(makeInput(), makeContext(dir));
+      await runPinnedInit(makeInput(), makeContext(dir));
+      const gitignoreContent = await readFile(join(dir, ".gitignore"), "utf8");
+      const matches = gitignoreContent.match(/\.forge\/pinned-audit\.log/g);
+      expect(matches).toHaveLength(1);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("merges defaults with existing manifest entries", async () => {
+    const dir = await makeTempDir();
+    try {
+      await mkdir(join(dir, ".forge"), { recursive: true });
+      await writeFile(
+        join(dir, ".forge", "pinned.yaml"),
+        "pinned:\n  - path: custom-file.md\n    mode: protect\n    reason: custom entry\n",
+      );
+
+      const result = await runPinnedInit(makeInput(), makeContext(dir));
+      expect(result.data?.manifestAction).toBe("merged");
+      expect(result.data?.entriesCount).toBe(DEFAULT_PINNED_ENTRIES.length + 1);
+
+      const content = await readFile(join(dir, ".forge", "pinned.yaml"), "utf8");
+      expect(content).toContain("custom-file.md");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("skips CI workflow when --ci not passed", async () => {
+    const dir = await makeTempDir();
+    try {
+      const result = await runPinnedInit(makeInput(), makeContext(dir));
+      expect(result.data?.ciWorkflowAction).toBe("skipped");
+      expect(existsSync(join(dir, ".github", "workflows", "pinned-check.yml"))).toBe(false);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("creates CI workflow when --ci passed", async () => {
+    const dir = await makeTempDir();
+    try {
+      const result = await runPinnedInit(makeInput({ ci: true }), makeContext(dir));
+      expect(result.data?.ciWorkflowAction).toBe("created");
+      expect(existsSync(join(dir, ".github", "workflows", "pinned-check.yml"))).toBe(true);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -0,0 +1,194 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Unit tests for RFC-0638 domain-neutral profile schema extensions.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0638: initial domain field tests — parsing, defaults, validation, backward compat.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect } from "vitest";
+import {
+  stackProfileSchema,
+  loadStackProfile,
+  listStackProfiles,
+  type StackProfile,
+} from "../profiles/stack-profile.ts";
+import {
+  profileInvariantSchema,
+  UNIVERSAL_TERMINOLOGY_KEYS,
+  TERMINOLOGY_DEFAULTS,
+} from "../profiles/profile-schema.ts";
+import { join } from "node:path";
+
+const FORGE_ROOT = join(import.meta.dirname, "..", "..");
+
+const baseProfile: StackProfile = {
+  schema: "forge/stack-profile@1",
+  id: "test-profile",
+  displayName: "Test Profile",
+  detect: { anyOf: ["astro.config.*"] },
+  workspace: {
+    dirs: ["sites"],
+    files: [{ path: "package.json", content: "{}" }],
+  },
+  install: [],
+};
+
+test("profile with all six domain fields parses successfully", () => {
+  const profile = {
+    ...baseProfile,
+    domain: "game",
+    register: "creative",
+    terminology: {
+      artifact: "game",
+      artifactPlural: "games",
+      module: "scene",
+      source: "game file",
+      output: "build",
+      verify: "playtest",
+      operator: "developer",
+    },
+    artifacts: [
+      {
+        id: "game",
+        extensions: [".ts"],
+        produce: { command: "ref(bindings.commands.produce)", output: "dist/{name}.js" },
+        validate: { command: "ref(bindings.commands.validate)" },
+        determinism: {
+          hashable: true,
+          inputs: ["game files", "assets", "vite version"],
+        },
+      },
+    ],
+    workspaceTypes: [
+      {
+        id: "game",
+        detect: { glob: "phaser.config.*" },
+        skills: ["fo-add-tests"],
+        agentsMdTemplate: "templates/game-agents.md",
+      },
+    ],
+    invariants: [
+      { id: "GAME-01", rule: "Games use kebab-case filenames", severity: "error" },
+      { id: "GAME-02", rule: "Scenes use contain mode by default", severity: "warning" },
+    ],
+  };
+  const result = stackProfileSchema.safeParse(profile);
+  expect(result.success).toBe(true);
+  if (result.success) {
+    expect(result.data.domain).toBe("game");
+    expect(result.data.register).toBe("creative");
+    expect(result.data.artifacts).toHaveLength(1);
+    expect(result.data.workspaceTypes).toHaveLength(1);
+    expect(result.data.invariants).toHaveLength(2);
+  }
+});
+
+test("profile with no domain fields parses successfully (backward compat)", () => {
+  const result = stackProfileSchema.safeParse(baseProfile);
+  expect(result.success).toBe(true);
+  if (result.success) {
+    expect(result.data.domain).toBeUndefined();
+    expect(result.data.terminology).toBeUndefined();
+    expect(result.data.artifacts).toBeUndefined();
+    expect(result.data.workspaceTypes).toBeUndefined();
+    expect(result.data.invariants).toBeUndefined();
+    expect(result.data.register).toBeUndefined();
+  }
+});
+
+test("profile with partial domain fields (only domain and register) parses", () => {
+  const profile = { ...baseProfile, domain: "book", register: "business" };
+  const result = stackProfileSchema.safeParse(profile);
+  expect(result.success).toBe(true);
+});
+
+test("terminology with unknown keys parses (open vocabulary)", () => {
+  const profile = {
+    ...baseProfile,
+    terminology: { artifact: "chapter", customKey: "custom-value" },
+  };
+  const result = stackProfileSchema.safeParse(profile);
+  expect(result.success).toBe(true);
+});
+
+test("invariants with invalid id format (lowercase) fails validation", () => {
+  const profile = {
+    ...baseProfile,
+    invariants: [{ id: "video-01", rule: "test rule", severity: "error" }],
+  };
+  const result = stackProfileSchema.safeParse(profile);
+  expect(result.success).toBe(false);
+});
+
+test("invariants with valid id format (VIDEO-01) passes", () => {
+  const profile = {
+    ...baseProfile,
+    invariants: [{ id: "VIDEO-01", rule: "test rule", severity: "error" }],
+  };
+  const result = stackProfileSchema.safeParse(profile);
+  expect(result.success).toBe(true);
+});
+
+test("profileInvariantSchema rejects invalid severity", () => {
+  const result = profileInvariantSchema.safeParse({
+    id: "VIDEO-01",
+    rule: "test",
+    severity: "critical",
+  });
+  expect(result.success).toBe(false);
+});
+
+test("register with invalid value fails validation", () => {
+  const profile = { ...baseProfile, register: "personal" };
+  const result = stackProfileSchema.safeParse(profile);
+  expect(result.success).toBe(false);
+});
+
+test("artifacts with missing required extensions field fails", () => {
+  const profile = {
+    ...baseProfile,
+    artifacts: [{ id: "composition" }],
+  };
+  const result = stackProfileSchema.safeParse(profile);
+  expect(result.success).toBe(false);
+});
+
+test("all shipped profiles parse without changes", () => {
+  const profiles = listStackProfiles(FORGE_ROOT);
+  expect(profiles.length).toBe(4);
+  for (const profile of profiles) {
+    expect(profile.id).toBeDefined();
+    expect(profile.workspace.dirs.length).toBeGreaterThan(0);
+    // Domain fields should be undefined for existing software-domain profiles
+    if (profile.id !== "godot-csharp") {
+      expect(profile.domain).toBeUndefined();
+      expect(profile.register).toBeUndefined();
+    }
+  }
+});
+
+test("shipped phaser-turborepo profile loads via loadStackProfile", () => {
+  const profile = loadStackProfile(join(FORGE_ROOT, "profiles", "phaser-turborepo.yaml"));
+  expect(profile.id).toBe("phaser-turborepo");
+});
+
+test("UNIVERSAL_TERMINOLOGY_KEYS contains the 7 documented keys", () => {
+  expect(UNIVERSAL_TERMINOLOGY_KEYS).toHaveLength(7);
+  expect(UNIVERSAL_TERMINOLOGY_KEYS).toContain("artifact");
+  expect(UNIVERSAL_TERMINOLOGY_KEYS).toContain("artifactPlural");
+  expect(UNIVERSAL_TERMINOLOGY_KEYS).toContain("module");
+  expect(UNIVERSAL_TERMINOLOGY_KEYS).toContain("source");
+  expect(UNIVERSAL_TERMINOLOGY_KEYS).toContain("output");
+  expect(UNIVERSAL_TERMINOLOGY_KEYS).toContain("verify");
+  expect(UNIVERSAL_TERMINOLOGY_KEYS).toContain("operator");
+});
+
+test("TERMINOLOGY_DEFAULTS maps each key to a non-empty default string", () => {
+  for (const key of UNIVERSAL_TERMINOLOGY_KEYS) {
+    const value = TERMINOLOGY_DEFAULTS[key];
+    expect(value).toBeDefined();
+    expect(value.length).toBeGreaterThan(0);
+  }
+});

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

@@ -0,0 +1,120 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Unit tests for forge.profile.validate command handler (RFC-0640).</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0640: initial profile-validate tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runProfileValidate } from "../onboarding/profile-validate.ts";
+import type { ForgeCommandInput, ForgeRuntimeContext } from "../types.ts";
+
+let tempDir: string;
+let profilesDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "profile-validate-test-"));
+  profilesDir = join(tempDir, "profiles");
+  await mkdir(profilesDir, { recursive: true });
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+function makeContext(forgeRoot: string): ForgeRuntimeContext {
+  return {
+    workspaceRoot: tempDir,
+    forgeRoot,
+    logger: {
+      section: () => {},
+      success: () => {},
+      warn: () => {},
+      error: () => {},
+      info: () => {},
+    },
+    dryRun: false,
+    outputFormat: "json",
+  };
+}
+
+test("profile.validate returns valid when profiles directory has valid YAML", async () => {
+  await writeFile(
+    join(profilesDir, "test-profile.yaml"),
+    `schema: "forge/stack-profile@1"\nid: test-profile\ndisplayName: Test Profile\ndetect:\n  anyOf:\n    - "package.json"\nworkspace:\n  dirs:\n    - "packages"\n  files: []\ninstall: []\n`,
+    "utf8",
+  );
+
+  const input: ForgeCommandInput = { argv: [], flags: {} };
+  const result = await runProfileValidate(input, makeContext(tempDir));
+
+  expect(result.data!.valid).toBe(true);
+  expect(result.data!.profiles).toHaveLength(1);
+  expect(result.data!.profiles[0].id).toBe("test-profile");
+  expect(result.data!.profiles[0].valid).toBe(true);
+  expect(result.exitCode).toBe(0);
+});
+
+test("profile.validate returns invalid when profile has schema errors", async () => {
+  await writeFile(
+    join(profilesDir, "bad-profile.yaml"),
+    `schema: "forge/stack-profile@1"\nid: ""\ndisplayName: Bad\ndetect:\n  anyOf: []\nworkspace:\n  dirs: []\n  files: []\n`,
+    "utf8",
+  );
+
+  const input: ForgeCommandInput = { argv: [], flags: {} };
+  const result = await runProfileValidate(input, makeContext(tempDir));
+
+  expect(result.data!.valid).toBe(false);
+  expect(result.data!.profiles).toHaveLength(1);
+  expect(result.data!.profiles[0].valid).toBe(false);
+  expect(result.data!.profiles[0].errors.length).toBeGreaterThan(0);
+  expect(result.exitCode).toBe(1);
+});
+
+test("profile.validate --id filters to single profile", async () => {
+  await writeFile(
+    join(profilesDir, "alpha.yaml"),
+    `schema: "forge/stack-profile@1"\nid: alpha\ndisplayName: Alpha\ndetect:\n  anyOf: ["package.json"]\nworkspace:\n  dirs: ["packages"]\n  files: []\ninstall: []\n`,
+    "utf8",
+  );
+  await writeFile(
+    join(profilesDir, "beta.yaml"),
+    `schema: "forge/stack-profile@1"\nid: beta\ndisplayName: Beta\ndetect:\n  anyOf: ["package.json"]\nworkspace:\n  dirs: ["packages"]\n  files: []\ninstall: []\n`,
+    "utf8",
+  );
+
+  const input: ForgeCommandInput = { argv: [], flags: { id: "alpha" } };
+  const result = await runProfileValidate(input, makeContext(tempDir));
+
+  expect(result.data!.profiles).toHaveLength(1);
+  expect(result.data!.profiles[0].id).toBe("alpha");
+});
+
+test("profile.validate returns valid=true with empty profiles when directory missing", async () => {
+  const input: ForgeCommandInput = { argv: [], flags: {} };
+  const result = await runProfileValidate(input, makeContext(join(tempDir, "nonexistent")));
+
+  expect(result.data!.valid).toBe(true);
+  expect(result.data!.profiles).toHaveLength(0);
+  expect(result.exitCode).toBe(0);
+});
+
+test("profile.validate validates profiles with domain fields (RFC-0638)", async () => {
+  await writeFile(
+    join(profilesDir, "domain-profile.yaml"),
+    `schema: "forge/stack-profile@1"\nid: domain-profile\ndisplayName: Domain Profile\ndetect:\n  anyOf: ["package.json"]\nworkspace:\n  dirs: ["packages"]\n  files: []\ninstall: []\ndomain: video\nterminology:\n  artifact: composition\nartifacts:\n  - id: video\n    extensions: [".mp4"]\nworkspaceTypes:\n  - id: scene\n    detect:\n      glob: "*.scene"\ninvariants:\n  - id: VIDEO-01\n    rule: "All videos must have audio"\n    severity: error\nregister: creative\n`,
+    "utf8",
+  );
+
+  const input: ForgeCommandInput = { argv: [], flags: {} };
+  const result = await runProfileValidate(input, makeContext(tempDir));
+
+  expect(result.data!.valid).toBe(true);
+  expect(result.data!.profiles[0].valid).toBe(true);
+});