diff --git a/packages/cli/src/__tests__/validate.test.ts b/packages/cli/src/__tests__/validate.test.ts
new file mode 100644
index 0000000..c0d2164
--- /dev/null
+++ b/packages/cli/src/__tests__/validate.test.ts
@@ -0,0 +1,513 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { validateCommand } from '../commands/validate.js';
+import * as core from '@md2wp/core';
+
+// Mock console methods to suppress output during tests
+vi.spyOn(console, 'log').mockImplementation(() => {});
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+// Mock process.exit to prevent actual exit and allow testing
+const mockExit = vi
+  .spyOn(process, 'exit')
+  .mockImplementation((code?: number | string | null | undefined) => {
+    throw new Error(`EXIT_${code}`);
+  });
+
+// Mock core functions
+vi.mock('@md2wp/core', async () => {
+  const actual = await vi.importActual('@md2wp/core');
+  return {
+    ...actual,
+    parseMarkdownFile: vi.fn(),
+    extractImages: vi.fn(),
+    processImagesForDryRun: vi.fn(),
+    transformToGutenberg: vi.fn(),
+    ImageCacheManager: vi.fn(),
+  };
+});
+
+describe('validateCommand', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Setup default ImageCacheManager mock
+    vi.mocked(core.ImageCacheManager).mockImplementation(
+      () =>
+        ({
+          load: vi.fn().mockResolvedValue(undefined),
+          save: vi.fn().mockResolvedValue(undefined),
+          get: vi.fn(),
+          set: vi.fn(),
+          has: vi.fn(),
+          delete: vi.fn(),
+          clear: vi.fn(),
+        }) as any,
+    );
+  });
+
+  describe('successful validation', () => {
+    it('should pass validation for valid markdown with minimal frontmatter', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test Post',
+        },
+        content: '# Hello World',
+        images: [],
+      });
+
+      vi.mocked(core.extractImages).mockReturnValue([]);
+      vi.mocked(core.transformToGutenberg).mockReturnValue(
+        '<!-- wp:heading --><h1>Hello World</h1><!-- /wp:heading -->',
+      );
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_0');
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    it('should pass validation for markdown with full frontmatter', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Complete Post',
+          status: 'publish',
+          slug: 'complete-post',
+          excerpt: 'This is an excerpt',
+          tags: ['tag1', 'tag2'],
+          categories: ['cat1', 'cat2'],
+          date: '2024-01-15T10:30:00Z',
+          wp_post_id: 456,
+          wp_url: 'https://example.com/complete-post',
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      vi.mocked(core.extractImages).mockReturnValue([]);
+      vi.mocked(core.transformToGutenberg).mockReturnValue(
+        '<!-- wp:paragraph -->Content<!-- /wp:paragraph -->',
+      );
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_0');
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    it('should pass validation with existing images', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Post with Images',
+        },
+        content: '![Alt](./image.png)',
+        images: [],
+      });
+
+      vi.mocked(core.extractImages).mockReturnValue([
+        { path: './image.png', alt: 'Alt' },
+      ]);
+
+      vi.mocked(core.processImagesForDryRun).mockResolvedValue([
+        {
+          path: './image.png',
+          absolutePath: '/abs/path/image.png',
+          alt: 'Alt',
+          validation: {
+            exists: true,
+            absolutePath: '/abs/path/image.png',
+            size: 1024,
+            sizeFormatted: '1.0 KB',
+            errors: [],
+            warnings: [],
+          },
+          cacheHit: false,
+        },
+      ]);
+
+      vi.mocked(core.transformToGutenberg).mockReturnValue('<!-- wp:image -->');
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_0');
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    it('should pass validation with cached images', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Post with Cached Image',
+        },
+        content: '![Cached](./cached.png)',
+        images: [],
+      });
+
+      vi.mocked(core.extractImages).mockReturnValue([
+        { path: './cached.png', alt: 'Cached' },
+      ]);
+
+      vi.mocked(core.processImagesForDryRun).mockResolvedValue([
+        {
+          path: './cached.png',
+          absolutePath: '/abs/path/cached.png',
+          alt: 'Cached',
+          validation: {
+            exists: true,
+            absolutePath: '/abs/path/cached.png',
+            size: 2048,
+            sizeFormatted: '2.0 KB',
+            errors: [],
+            warnings: [],
+          },
+          cacheHit: true,
+          cachedMediaId: 123,
+        },
+      ]);
+
+      vi.mocked(core.transformToGutenberg).mockReturnValue('<!-- wp:image -->');
+
+      await expect(
+        validateCommand('test.md', { verbose: true }),
+      ).rejects.toThrow('EXIT_0');
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+  });
+
+  describe('frontmatter validation errors', () => {
+    it('should fail when title is missing', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          status: 'draft',
+        } as any,
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when title is not a string', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 123 as any,
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when status is invalid', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          status: 'invalid' as any,
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when slug is not a string', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          slug: 123 as any,
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when excerpt is not a string', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          excerpt: 123 as any,
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when tags is not an array', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          tags: 'tag1,tag2' as any,
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when tags contains non-strings', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          tags: ['tag1', 123] as any,
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when categories is not an array', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          categories: 'cat1,cat2' as any,
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when categories contains non-strings', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          categories: ['cat1', 123] as any,
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when date is not a string', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          date: 123 as any,
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when date is invalid ISO format', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          date: 'not-a-date',
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when wp_post_id is not a number', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          wp_post_id: '123' as any,
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when wp_url is not a string', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          wp_url: 123 as any,
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('image validation errors', () => {
+    it('should fail when images are missing', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+        },
+        content: '![Missing](./missing.png)',
+        images: [],
+      });
+
+      vi.mocked(core.extractImages).mockReturnValue([
+        { path: './missing.png', alt: 'Missing' },
+      ]);
+
+      vi.mocked(core.processImagesForDryRun).mockResolvedValue([
+        {
+          path: './missing.png',
+          absolutePath: '/abs/path/missing.png',
+          alt: 'Missing',
+          validation: {
+            exists: false,
+            absolutePath: '/abs/path/missing.png',
+            errors: ['File not found'],
+            warnings: [],
+          },
+          cacheHit: false,
+        },
+      ]);
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should fail when multiple images are missing', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+        },
+        content: '![Missing1](./missing1.png) ![Missing2](./missing2.png)',
+        images: [],
+      });
+
+      vi.mocked(core.extractImages).mockReturnValue([
+        { path: './missing1.png', alt: 'Missing1' },
+        { path: './missing2.png', alt: 'Missing2' },
+      ]);
+
+      vi.mocked(core.processImagesForDryRun).mockResolvedValue([
+        {
+          path: './missing1.png',
+          absolutePath: '/abs/path/missing1.png',
+          alt: 'Missing1',
+          validation: {
+            exists: false,
+            absolutePath: '/abs/path/missing1.png',
+            errors: ['File not found'],
+            warnings: [],
+          },
+          cacheHit: false,
+        },
+        {
+          path: './missing2.png',
+          absolutePath: '/abs/path/missing2.png',
+          alt: 'Missing2',
+          validation: {
+            exists: false,
+            absolutePath: '/abs/path/missing2.png',
+            errors: ['File not found'],
+            warnings: [],
+          },
+          cacheHit: false,
+        },
+      ]);
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_1');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('valid date formats', () => {
+    it('should accept ISO 8601 date with time and timezone', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          date: '2024-01-15T10:30:00Z',
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      vi.mocked(core.extractImages).mockReturnValue([]);
+      vi.mocked(core.transformToGutenberg).mockReturnValue(
+        '<!-- wp:paragraph -->',
+      );
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_0');
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    it('should accept ISO 8601 date without time', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          date: '2024-01-15',
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      vi.mocked(core.extractImages).mockReturnValue([]);
+      vi.mocked(core.transformToGutenberg).mockReturnValue(
+        '<!-- wp:paragraph -->',
+      );
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_0');
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+  });
+
+  describe('status field validation', () => {
+    it('should accept status "draft"', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          status: 'draft',
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      vi.mocked(core.extractImages).mockReturnValue([]);
+      vi.mocked(core.transformToGutenberg).mockReturnValue(
+        '<!-- wp:paragraph -->',
+      );
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_0');
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    it('should accept status "publish"', async () => {
+      vi.mocked(core.parseMarkdownFile).mockResolvedValue({
+        frontmatter: {
+          title: 'Test',
+          status: 'publish',
+        },
+        content: 'Content',
+        images: [],
+      });
+
+      vi.mocked(core.extractImages).mockReturnValue([]);
+      vi.mocked(core.transformToGutenberg).mockReturnValue(
+        '<!-- wp:paragraph -->',
+      );
+
+      await expect(validateCommand('test.md')).rejects.toThrow('EXIT_0');
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+  });
+});
diff --git a/packages/cli/src/cli.ts b/packages/cli/src/cli.ts
index c9b959e..007543e 100644
--- a/packages/cli/src/cli.ts
+++ b/packages/cli/src/cli.ts
@@ -8,6 +8,7 @@ import { Command } from 'commander';
 import { version } from './index.js';
 import { initCommand } from './commands/init.js';
 import { publishCommand } from './commands/publish.js';
+import { validateCommand } from './commands/validate.js';
 
 const program = new Command();
 
@@ -46,9 +47,15 @@ program
 
 program
   .command('validate <file>')
-  .description('Validate frontmatter and config')
-  .action((file: string) => {
-    console.log('TODO: Implement validate command', { file });
+  .description('Validate markdown file before publishing')
+  .option('--verbose', 'Show detailed validation output')
+  .action(async (file: string, options: { verbose?: boolean }) => {
+    try {
+      await validateCommand(file, options);
+    } catch (error) {
+      console.error('Error:', (error as Error).message);
+      process.exit(1);
+    }
   });
 
 program
diff --git a/packages/cli/src/commands/validate.ts b/packages/cli/src/commands/validate.ts
new file mode 100644
index 0000000..b2c33c6
--- /dev/null
+++ b/packages/cli/src/commands/validate.ts
@@ -0,0 +1,280 @@
+/**
+ * Validate command - Validate markdown file without publishing
+ */
+
+import { resolve } from 'path';
+import {
+  parseMarkdownFile,
+  extractImages,
+  processImagesForDryRun,
+  transformToGutenberg,
+  ImageCacheManager,
+  formatBytes,
+  type ImageMap,
+  type Frontmatter,
+} from '@md2wp/core';
+
+interface ValidateOptions {
+  verbose?: boolean;
+}
+
+/**
+ * Validate a markdown file
+ */
+export async function validateCommand(
+  file: string,
+  options: ValidateOptions = {},
+): Promise<void> {
+  let success = false;
+
+  try {
+    console.log('🔍 Validating markdown file...\n');
+
+    // Resolve file path
+    const absolutePath = resolve(process.cwd(), file);
+
+    // Parse markdown file
+    console.log('📄 Parsing markdown...');
+    const parsed = await parseMarkdownFile(absolutePath);
+    console.log('✅ Markdown parsed successfully\n');
+
+    // Validate frontmatter
+    console.log('📋 Validating frontmatter...');
+    validateFrontmatter(parsed.frontmatter);
+    console.log('✅ Frontmatter is valid\n');
+
+    // Show frontmatter summary
+    if (options.verbose) {
+      console.log('📋 Frontmatter:');
+      console.log(JSON.stringify(parsed.frontmatter, null, 2));
+      console.log('');
+    } else {
+      console.log('📋 Frontmatter:');
+      console.log(`   Title: ${parsed.frontmatter.title}`);
+      console.log(`   Status: ${parsed.frontmatter.status || 'draft'}`);
+      if (parsed.frontmatter.slug) {
+        console.log(`   Slug: ${parsed.frontmatter.slug}`);
+      }
+      if (parsed.frontmatter.excerpt) {
+        console.log(
+          `   Excerpt: ${parsed.frontmatter.excerpt.substring(0, 50)}${parsed.frontmatter.excerpt.length > 50 ? '...' : ''}`,
+        );
+      }
+      if (parsed.frontmatter.tags && parsed.frontmatter.tags.length > 0) {
+        console.log(`   Tags: ${parsed.frontmatter.tags.join(', ')}`);
+      }
+      if (
+        parsed.frontmatter.categories &&
+        parsed.frontmatter.categories.length > 0
+      ) {
+        console.log(
+          `   Categories: ${parsed.frontmatter.categories.join(', ')}`,
+        );
+      }
+      console.log('');
+    }
+
+    // Extract and validate images
+    const images = extractImages(parsed.content);
+
+    if (images.length > 0) {
+      console.log(`📸 Validating ${images.length} image(s)...`);
+
+      // Load cache
+      const cache = new ImageCacheManager();
+      await cache.load();
+
+      // Process images for validation
+      const processed = await processImagesForDryRun(
+        images,
+        absolutePath,
+        cache,
+      );
+
+      // Check for missing images
+      const missingImages = processed.filter((img) => !img.validation.exists);
+      const existingImages = processed.filter((img) => img.validation.exists);
+      const cachedImages = processed.filter((img) => img.cacheHit);
+
+      if (missingImages.length > 0) {
+        console.error('\n❌ Missing images:');
+        missingImages.forEach((img) => {
+          console.error(`   • ${img.path}`);
+          console.error(`     ${img.absolutePath}`);
+        });
+        console.error('');
+        throw new Error(
+          `Validation failed: ${missingImages.length} image(s) not found`,
+        );
+      }
+
+      // Show image summary
+      console.log('✅ All images exist\n');
+
+      if (options.verbose) {
+        console.log('📸 Image details:');
+        existingImages.forEach((img) => {
+          console.log(`   • ${img.path}`);
+          console.log(`     Path: ${img.absolutePath}`);
+          if (img.validation.sizeFormatted) {
+            console.log(`     Size: ${img.validation.sizeFormatted}`);
+          }
+          if (img.cacheHit) {
+            console.log(
+              `     Cache: ✅ Cached (Media ID: ${img.cachedMediaId})`,
+            );
+          } else {
+            console.log('     Cache: ⚠️  Will be uploaded');
+          }
+          if (img.alt) {
+            console.log(`     Alt: ${img.alt}`);
+          }
+        });
+        console.log('');
+      } else {
+        console.log('📸 Image summary:');
+        console.log(`   Total: ${images.length}`);
+        console.log(`   Cached: ${cachedImages.length}`);
+        console.log(
+          `   To upload: ${existingImages.length - cachedImages.length}`,
+        );
+
+        // Calculate total size of images to upload
+        const toUploadSize = existingImages
+          .filter((img) => !img.cacheHit)
+          .reduce((sum, img) => sum + (img.validation.size || 0), 0);
+
+        if (toUploadSize > 0) {
+          console.log(`   Upload size: ${formatBytes(toUploadSize)}`);
+        }
+        console.log('');
+      }
+    } else {
+      console.log('📸 No images found\n');
+    }
+
+    // Generate Gutenberg preview
+    console.log('🎨 Generating Gutenberg blocks...');
+    const imageMap: ImageMap = {}; // Empty map for validation
+    const gutenberg = transformToGutenberg(parsed.content, imageMap);
+    console.log('✅ Gutenberg blocks generated\n');
+
+    if (options.verbose) {
+      console.log('🎨 Gutenberg preview:');
+      console.log('─'.repeat(60));
+      console.log(gutenberg);
+      console.log('─'.repeat(60));
+      console.log('');
+    } else {
+      const blockCount = (gutenberg.match(/<!-- wp:/g) || []).length;
+      console.log('🎨 Gutenberg preview:');
+      console.log(`   Blocks: ${blockCount}`);
+      console.log(`   Characters: ${gutenberg.length}`);
+      console.log('');
+    }
+
+    // Success summary
+    console.log('━'.repeat(60));
+    console.log('✅ VALIDATION PASSED');
+    console.log('━'.repeat(60));
+    console.log('');
+    console.log('✓ Frontmatter is valid');
+    console.log(`✓ All ${images.length} image(s) exist`);
+    console.log('✓ Gutenberg blocks generated successfully');
+    console.log('');
+    console.log('💡 Ready to publish with: md2wp publish ' + file);
+    console.log('');
+
+    success = true;
+  } catch (error) {
+    console.error('');
+    console.error('━'.repeat(60));
+    console.error('❌ VALIDATION FAILED');
+    console.error('━'.repeat(60));
+    console.error('');
+
+    if (error instanceof Error) {
+      console.error(error.message);
+    } else {
+      console.error('Unknown error occurred');
+    }
+
+    console.error('');
+  }
+
+  process.exit(success ? 0 : 1);
+}
+
+/**
+ * Validate frontmatter has required fields
+ */
+function validateFrontmatter(frontmatter: Frontmatter): void {
+  // Check required field: title
+  if (!frontmatter.title || typeof frontmatter.title !== 'string') {
+    throw new Error('Frontmatter must include a "title" field (string)');
+  }
+
+  // Validate status if present
+  if (frontmatter.status) {
+    if (
+      typeof frontmatter.status !== 'string' ||
+      !['draft', 'publish'].includes(frontmatter.status)
+    ) {
+      throw new Error('Frontmatter "status" must be "draft" or "publish"');
+    }
+  }
+
+  // Validate slug if present
+  if (frontmatter.slug && typeof frontmatter.slug !== 'string') {
+    throw new Error('Frontmatter "slug" must be a string');
+  }
+
+  // Validate excerpt if present
+  if (frontmatter.excerpt && typeof frontmatter.excerpt !== 'string') {
+    throw new Error('Frontmatter "excerpt" must be a string');
+  }
+
+  // Validate tags if present
+  if (frontmatter.tags) {
+    if (!Array.isArray(frontmatter.tags)) {
+      throw new Error('Frontmatter "tags" must be an array');
+    }
+    if (!frontmatter.tags.every((tag) => typeof tag === 'string')) {
+      throw new Error('Frontmatter "tags" must be an array of strings');
+    }
+  }
+
+  // Validate categories if present
+  if (frontmatter.categories) {
+    if (!Array.isArray(frontmatter.categories)) {
+      throw new Error('Frontmatter "categories" must be an array');
+    }
+    if (!frontmatter.categories.every((cat) => typeof cat === 'string')) {
+      throw new Error('Frontmatter "categories" must be an array of strings');
+    }
+  }
+
+  // Validate date if present
+  if (frontmatter.date) {
+    if (typeof frontmatter.date !== 'string') {
+      throw new Error('Frontmatter "date" must be a string (ISO 8601 format)');
+    }
+    // Try to parse date
+    const dateObj = new Date(frontmatter.date);
+    if (isNaN(dateObj.getTime())) {
+      throw new Error(
+        'Frontmatter "date" must be a valid ISO 8601 date (e.g., "2024-01-15" or "2024-01-15T10:30:00Z")',
+      );
+    }
+  }
+
+  // Validate wp_post_id if present (should be number)
+  if (frontmatter.wp_post_id && typeof frontmatter.wp_post_id !== 'number') {
+    throw new Error('Frontmatter "wp_post_id" must be a number');
+  }
+
+  // Validate wp_url if present
+  if (frontmatter.wp_url && typeof frontmatter.wp_url !== 'string') {
+    throw new Error('Frontmatter "wp_url" must be a string');
+  }
+}