diff --git a/CHANGELOG.md b/CHANGELOG.md
index 47aeb64c..ae646c03 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -35,11 +35,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **BREAKING**: Legacy DocumentControls component from TestDrive JSUI plugin system - all control panel functionality now provided by enhanced control panels (ContentsControl, StatusControl, DebugControl, EditControl) with Reset All button functionality moved to EditControl for better maintainability and elimination of code duplication
 
 ### In Progress
-- **Schema-of-Schemas Implementation** (Phase 1 of 6)
-  - Implementing filename validation for schema naming convention
-  - Building markdown schema loader to parse `.md` schema files
-  - Creating schema-for-schemas metaschema for schema validation
-  - Planning migration of 5 existing schemas to new format (will remove 2 duplicates)
+- **Schema-of-Schemas Implementation** (Phase 2 of 6 - Completed ✅)
+  - ✅ Phase 1: Filename validation for schema naming convention (`markitect/schema_naming.py`, 50 tests)
+  - ✅ Phase 2: Markdown schema loader to parse `.md` schema files (`markitect/schema_loader.py`, 35 tests)
+  - ⏳ Phase 3: Creating schema-for-schemas metaschema for schema validation
+  - ⏳ Phase 4: Migration of 5 existing schemas to new format (will remove 2 duplicates)
+  - ⏳ Phase 5: CLI updates and documentation
+  - ⏳ Phase 6: Integration testing and validation
 
 ## [0.9.0] - 2025-11-14
 
diff --git a/TODO.md b/TODO.md
index 156e6575..866359fb 100644
--- a/TODO.md
+++ b/TODO.md
@@ -12,33 +12,40 @@ The structure organizes **future tasks** by their impact, just as a changelog or
 
 This section is for tasks currently being discussed with or worked on by the coding assistant. These are the ephemeral, flow-of-thought tasks.
 
-### Schema-of-Schemas Implementation (Active - Phase 1)
+### Schema-of-Schemas Implementation (Active - Phase 2)
 
-**Status:** Phase 1 - Filename Convention & Validation (In Progress)
+**Status:** Phase 2 - Markdown Schema Loader (Completed ✅)
 **Workplan:** See `roadmap/schema-of-schemas/WORKPLAN.md`
 
 **Current Goals:**
 1. ✅ Establish naming convention: `{domain}-schema-v{major}.{minor}.md`
-2. 🔄 Implement filename validation logic
-3. 🔄 Update CLI with validation
-4. ⏳ Create markdown schema loader
-5. ⏳ Build schema-for-schemas metaschema
+2. ✅ Implement filename validation logic
+3. ✅ Create markdown schema loader
+4. ✅ Create example markdown schema
+5. ⏳ Build schema-for-schemas metaschema (Next: Phase 3)
 6. ⏳ Migrate existing schemas to new format
 
 **Phase 1 Tasks (Completed ✅):**
 - [x] Write `markitect/schema_naming.py` with validation logic
 - [x] Add unit tests for filename validation (50 tests, 100% passing)
-- [ ] Update `schema-ingest` command with validation (Next: Phase 2)
 - [x] Create SCHEMA_NAMING_SPEC.md documentation
 
+**Phase 2 Tasks (Completed ✅):**
+- [x] Implement MarkdownSchemaLoader class (markitect/schema_loader.py, 515 lines)
+- [x] Add frontmatter extraction (YAML)
+- [x] Add JSON code block extraction with section preference
+- [x] Add metadata merging with x-markitect-source tracking
+- [x] Write comprehensive unit tests (35 tests, 100% passing)
+- [x] Create example markdown schema (manpage-schema-v1.0.md)
+- [x] Create SCHEMA_LOADER_GUIDE.md documentation
+
 **Next Phases:**
-- Phase 2: Markdown Schema Loader (2-3 days)
 - Phase 3: Schema-for-Schemas Metaschema (2 days)
 - Phase 4: Schema Migration (1-2 days)
 - Phase 5: CLI & Documentation Updates (1 day)
 - Phase 6: Testing & Validation (1 day)
 
-**Expected Completion:** 8-10 days total
+**Expected Completion:** 6-7 days remaining
 
 ---
 
@@ -131,6 +138,31 @@ The **capability-capability** includes:
 - Includes content control and validation rules
 - Full documentation and usage examples (README.md)
 
+### 2026-01-04 - Phase 2: Markdown Schema Loader
+- ✅ Implemented MarkdownSchemaLoader class (markitect/schema_loader.py, 515 lines)
+- ✅ YAML frontmatter extraction with validation
+- ✅ JSON code block extraction with "Schema Definition" section preference
+- ✅ Metadata merging with x-markitect-source tracking
+- ✅ Schema saving with template support and round-trip capability
+- ✅ Comprehensive test suite (35 unit tests, 100% passing)
+- ✅ Created example markdown schema (manpage-schema-v1.0.md)
+- ✅ Created SCHEMA_LOADER_GUIDE.md with complete usage documentation
+
+**Key Features Delivered:**
+- Markdown-first schema format with embedded JSON
+- Frontmatter metadata merges into schema ($id, version, status)
+- Automatic detection of multiple JSON blocks
+- Schema structure validation helper
+- Error handling for binary files and invalid formats
+- List JSON blocks helper for debugging
+- Full round-trip save/load capability
+
+**Example Markdown Schema:**
+- manpage-schema-v1.0.md demonstrating complete format
+- Includes frontmatter, documentation, and JSON schema
+- Shows section classification and content control
+- Follows naming convention: {domain}-schema-v{major}.{minor}.md
+
 ### 2025-12-17 - Architecture Refactoring
 - ✅ Implemented ReusableCapabilitiesArchitecture v0.1
 - ✅ Added feedback capability to issue-facade
diff --git a/markitect/schema_loader.py b/markitect/schema_loader.py
new file mode 100644
index 00000000..abcad92d
--- /dev/null
+++ b/markitect/schema_loader.py
@@ -0,0 +1,503 @@
+"""
+Schema Loader - Extract JSON schemas from markdown files.
+
+This module provides functionality to load schemas from markdown files that
+contain embedded JSON schemas in code blocks, along with YAML frontmatter
+metadata and rich documentation.
+
+Markdown Schema Format:
+    ---
+    schema-id: "https://markitect.dev/schemas/domain/v1"
+    version: "1.0.0"
+    status: "stable|draft|deprecated"
+    ---
+
+    # Schema Title v1.0
+
+    ## Documentation sections...
+
+    ## Schema Definition
+
+    ```json
+    {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      ...
+    }
+    ```
+
+This enables:
+- Rich documentation alongside schemas
+- Version history in same file
+- Human-readable schema files
+- Markdown-first approach aligned with MarkiTect philosophy
+"""
+
+import re
+import json
+import yaml
+from pathlib import Path
+from typing import Dict, Any, Optional, List, Tuple
+
+
+class SchemaLoaderError(Exception):
+    """Base exception for schema loading errors."""
+    pass
+
+
+class InvalidSchemaFormatError(SchemaLoaderError):
+    """Schema file format is invalid."""
+    pass
+
+
+class SchemaNotFoundError(SchemaLoaderError):
+    """No JSON schema found in markdown file."""
+    pass
+
+
+class MarkdownSchemaLoader:
+    """
+    Load and parse markdown schema files.
+
+    Supports:
+    - YAML frontmatter for metadata
+    - JSON code blocks for schema definition
+    - Validation of schema structure
+    - Metadata merging
+
+    Example:
+        >>> loader = MarkdownSchemaLoader()
+        >>> schema_data = loader.load_schema(Path("manpage-schema-v1.0.md"))
+        >>> schema = schema_data['schema']
+        >>> metadata = schema_data['metadata']
+    """
+
+    def __init__(self):
+        """Initialize the schema loader with regex patterns."""
+        # Pattern to match YAML frontmatter
+        # Matches: --- ... --- at start of file
+        self.frontmatter_pattern = re.compile(
+            r'^---\s*\n(.*?)\n---\s*\n',
+            re.DOTALL | re.MULTILINE
+        )
+
+        # Pattern to match JSON code blocks
+        # Matches: ```json ... ```
+        self.json_code_block_pattern = re.compile(
+            r'```json\s*\n(.*?)\n```',
+            re.DOTALL | re.MULTILINE
+        )
+
+        # Pattern to find Schema Definition section
+        # This helps us find the right JSON block if there are multiple
+        self.schema_section_pattern = re.compile(
+            r'##\s+Schema Definition\s*\n',
+            re.MULTILINE
+        )
+
+    def load_schema(self, md_path: Path) -> Dict[str, Any]:
+        """
+        Load schema from markdown file.
+
+        Args:
+            md_path: Path to markdown schema file
+
+        Returns:
+            Dictionary containing:
+                - schema: Extracted JSON schema (dict)
+                - metadata: Frontmatter metadata (dict)
+                - documentation: Full markdown content (str)
+                - source_file: Source file path (str)
+
+        Raises:
+            FileNotFoundError: If schema file doesn't exist
+            InvalidSchemaFormatError: If file format is invalid
+            SchemaNotFoundError: If no JSON schema found
+
+        Example:
+            >>> loader = MarkdownSchemaLoader()
+            >>> data = loader.load_schema(Path("manpage-schema-v1.0.md"))
+            >>> print(data['schema']['title'])
+            'Unix Manual Page Schema'
+        """
+        if not md_path.exists():
+            raise FileNotFoundError(f"Schema file not found: {md_path}")
+
+        # Read file content
+        try:
+            content = md_path.read_text(encoding='utf-8')
+        except Exception as e:
+            raise InvalidSchemaFormatError(f"Failed to read schema file: {e}")
+
+        # Extract frontmatter
+        metadata = self._extract_frontmatter(content)
+
+        # Extract JSON schema
+        schema = self._extract_json_schema(content)
+
+        if not schema:
+            raise SchemaNotFoundError(
+                f"No JSON schema found in {md_path}. "
+                f"Expected a ```json code block with schema definition."
+            )
+
+        # Merge metadata into schema
+        schema = self._merge_metadata(schema, metadata, md_path)
+
+        return {
+            'schema': schema,
+            'metadata': metadata,
+            'documentation': content,
+            'source_file': str(md_path)
+        }
+
+    def _extract_frontmatter(self, content: str) -> Dict[str, Any]:
+        """
+        Extract YAML frontmatter from markdown content.
+
+        Args:
+            content: Markdown file content
+
+        Returns:
+            Dictionary of frontmatter metadata (empty if none found)
+
+        Raises:
+            InvalidSchemaFormatError: If YAML is malformed
+        """
+        match = self.frontmatter_pattern.search(content)
+        if not match:
+            return {}
+
+        yaml_content = match.group(1)
+        try:
+            metadata = yaml.safe_load(yaml_content) or {}
+            if not isinstance(metadata, dict):
+                raise InvalidSchemaFormatError(
+                    f"Frontmatter must be a YAML dictionary, got {type(metadata)}"
+                )
+            return metadata
+        except yaml.YAMLError as e:
+            raise InvalidSchemaFormatError(f"Invalid YAML frontmatter: {e}")
+
+    def _extract_json_schema(self, content: str) -> Optional[Dict[str, Any]]:
+        """
+        Extract JSON schema from markdown code blocks.
+
+        Prefers JSON blocks under "## Schema Definition" section,
+        but will use first JSON block if no Schema Definition section found.
+
+        Args:
+            content: Markdown file content
+
+        Returns:
+            JSON schema dictionary or None if not found
+
+        Raises:
+            InvalidSchemaFormatError: If JSON is malformed
+        """
+        # Find all JSON code blocks
+        json_blocks = self.json_code_block_pattern.findall(content)
+
+        if not json_blocks:
+            return None
+
+        # Try to find the Schema Definition section
+        schema_section_match = self.schema_section_pattern.search(content)
+
+        if schema_section_match:
+            # Find JSON block that comes after Schema Definition section
+            section_pos = schema_section_match.end()
+
+            # Re-search for JSON blocks starting from section position
+            remaining_content = content[section_pos:]
+            section_json_blocks = self.json_code_block_pattern.findall(remaining_content)
+
+            if section_json_blocks:
+                json_text = section_json_blocks[0]
+            else:
+                # Fallback to first JSON block in entire document
+                json_text = json_blocks[0]
+        else:
+            # No Schema Definition section, use first JSON block
+            json_text = json_blocks[0]
+
+        # Parse JSON
+        try:
+            schema = json.loads(json_text)
+            if not isinstance(schema, dict):
+                raise InvalidSchemaFormatError(
+                    f"Schema must be a JSON object, got {type(schema)}"
+                )
+            return schema
+        except json.JSONDecodeError as e:
+            raise InvalidSchemaFormatError(f"Invalid JSON schema: {e}")
+
+    def _merge_metadata(
+        self,
+        schema: Dict[str, Any],
+        metadata: Dict[str, Any],
+        source_file: Path
+    ) -> Dict[str, Any]:
+        """
+        Merge frontmatter metadata into schema.
+
+        Adds x-markitect-source extension with file info and metadata.
+        Optionally overrides schema fields with frontmatter values.
+
+        Args:
+            schema: JSON schema dictionary
+            metadata: Frontmatter metadata dictionary
+            source_file: Path to source file
+
+        Returns:
+            Schema with merged metadata
+        """
+        # Create a copy to avoid modifying original
+        merged_schema = schema.copy()
+
+        # Add MarkiTect-specific source metadata
+        merged_schema['x-markitect-source'] = {
+            'file': str(source_file),
+            'filename': source_file.name,
+            'format': 'markdown',
+            'frontmatter': metadata
+        }
+
+        # Override schema fields with frontmatter if present
+        # This allows frontmatter to be the source of truth for metadata
+        if 'version' in metadata:
+            merged_schema['version'] = metadata['version']
+
+        if 'schema-id' in metadata:
+            merged_schema['$id'] = metadata['schema-id']
+
+        if 'status' in metadata:
+            if 'x-markitect-metadata' not in merged_schema:
+                merged_schema['x-markitect-metadata'] = {}
+            merged_schema['x-markitect-metadata']['status'] = metadata['status']
+
+        return merged_schema
+
+    def save_schema(
+        self,
+        schema: Dict[str, Any],
+        md_path: Path,
+        template: Optional[str] = None,
+        frontmatter: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Save schema as markdown file.
+
+        Args:
+            schema: JSON schema dictionary to save
+            md_path: Output path for markdown file
+            template: Optional markdown template string
+            frontmatter: Optional frontmatter metadata (extracted from schema if not provided)
+
+        Raises:
+            InvalidSchemaFormatError: If schema is invalid
+
+        Example:
+            >>> loader = MarkdownSchemaLoader()
+            >>> loader.save_schema(
+            ...     schema={'title': 'My Schema', ...},
+            ...     md_path=Path('my-schema-v1.0.md')
+            ... )
+        """
+        if template:
+            # Use provided template
+            content = self._render_template(template, schema, frontmatter)
+        else:
+            # Generate basic markdown
+            content = self._generate_markdown(schema, frontmatter)
+
+        # Create parent directory if needed
+        md_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write file
+        try:
+            md_path.write_text(content, encoding='utf-8')
+        except Exception as e:
+            raise InvalidSchemaFormatError(f"Failed to write schema file: {e}")
+
+    def _generate_markdown(
+        self,
+        schema: Dict[str, Any],
+        frontmatter: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        Generate markdown from schema.
+
+        Args:
+            schema: JSON schema dictionary
+            frontmatter: Optional frontmatter metadata
+
+        Returns:
+            Markdown content as string
+        """
+        # Extract metadata from schema
+        title = schema.get('title', 'Untitled Schema')
+        version = schema.get('version', '1.0.0')
+        description = schema.get('description', '')
+        schema_id = schema.get('$id', '')
+
+        # Build frontmatter
+        if frontmatter is None:
+            frontmatter = {}
+
+        # Set defaults
+        if 'schema-id' not in frontmatter and schema_id:
+            frontmatter['schema-id'] = schema_id
+        if 'version' not in frontmatter:
+            frontmatter['version'] = version
+        if 'status' not in frontmatter:
+            frontmatter['status'] = 'draft'
+
+        # Generate frontmatter YAML
+        frontmatter_yaml = yaml.dump(
+            frontmatter,
+            default_flow_style=False,
+            allow_unicode=True
+        ).strip()
+
+        # Generate JSON (pretty-printed)
+        schema_json = json.dumps(schema, indent=2, ensure_ascii=False)
+
+        # Build markdown content
+        md_content = f"""---
+{frontmatter_yaml}
+---
+
+# {title} v{version}
+
+## Overview
+
+{description}
+
+## Usage
+
+```bash
+markitect validate document.md --schema {Path(frontmatter.get('schema-id', 'schema')).name}
+```
+
+## Schema Definition
+
+```json
+{schema_json}
+```
+
+## Version History
+
+### v{version}
+- Initial version
+"""
+
+        return md_content
+
+    def _render_template(
+        self,
+        template: str,
+        schema: Dict[str, Any],
+        frontmatter: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        Render markdown from template.
+
+        Simple template rendering using string formatting.
+        For complex templates, consider using Jinja2 or similar.
+
+        Args:
+            template: Template string
+            schema: JSON schema dictionary
+            frontmatter: Optional frontmatter metadata
+
+        Returns:
+            Rendered markdown content
+        """
+        # Build context for template
+        context = {
+            'title': schema.get('title', 'Untitled'),
+            'version': schema.get('version', '1.0.0'),
+            'description': schema.get('description', ''),
+            'schema_id': schema.get('$id', ''),
+            'schema_json': json.dumps(schema, indent=2, ensure_ascii=False),
+            'frontmatter': frontmatter or {},
+        }
+
+        # Simple template rendering
+        try:
+            return template.format(**context)
+        except KeyError as e:
+            raise InvalidSchemaFormatError(f"Template missing key: {e}")
+
+    def list_json_blocks(self, content: str) -> List[Tuple[int, str]]:
+        """
+        List all JSON code blocks in markdown content.
+
+        Useful for debugging or when multiple JSON blocks exist.
+
+        Args:
+            content: Markdown file content
+
+        Returns:
+            List of (position, json_content) tuples
+
+        Example:
+            >>> loader = MarkdownSchemaLoader()
+            >>> content = Path('schema.md').read_text()
+            >>> blocks = loader.list_json_blocks(content)
+            >>> print(f"Found {len(blocks)} JSON blocks")
+        """
+        blocks = []
+        for match in self.json_code_block_pattern.finditer(content):
+            blocks.append((match.start(), match.group(1)))
+        return blocks
+
+    def validate_schema_structure(self, schema: Dict[str, Any]) -> List[str]:
+        """
+        Validate basic schema structure.
+
+        Checks for required JSON Schema fields and MarkiTect conventions.
+
+        Args:
+            schema: JSON schema dictionary
+
+        Returns:
+            List of warning/error messages (empty if valid)
+
+        Example:
+            >>> loader = MarkdownSchemaLoader()
+            >>> issues = loader.validate_schema_structure(schema)
+            >>> if issues:
+            ...     print("Schema issues:", issues)
+        """
+        issues = []
+
+        # Check required JSON Schema fields
+        if '$schema' not in schema:
+            issues.append("Missing required field: $schema")
+
+        if 'type' not in schema:
+            issues.append("Missing recommended field: type")
+
+        if 'title' not in schema:
+            issues.append("Missing recommended field: title")
+
+        if 'description' not in schema:
+            issues.append("Missing recommended field: description")
+
+        # Check MarkiTect conventions
+        if 'version' not in schema:
+            issues.append("Missing MarkiTect convention: version field")
+
+        if '$id' not in schema:
+            issues.append("Missing recommended field: $id")
+
+        # Check $id format if present
+        if '$id' in schema:
+            schema_id = schema['$id']
+            if not isinstance(schema_id, str):
+                issues.append("$id must be a string")
+            elif not schema_id.startswith('https://'):
+                issues.append("$id should be a full HTTPS URL")
+
+        return issues
diff --git a/markitect/schemas/manpage-schema-v1.0.md b/markitect/schemas/manpage-schema-v1.0.md
new file mode 100644
index 00000000..ce0826b0
--- /dev/null
+++ b/markitect/schemas/manpage-schema-v1.0.md
@@ -0,0 +1,333 @@
+---
+schema-id: "https://markitect.dev/schemas/manpage/v1.0"
+version: "1.0.0"
+status: "stable"
+domain: "manpage"
+description: "JSON schema for Unix-style manual pages with section classification and content control"
+---
+
+# Unix Manual Page Schema v1.0
+
+## Overview
+
+This schema defines the structure and validation rules for Unix-style manual pages (manpages) in MarkiTect's markdown format. It includes comprehensive section classification, content control patterns, and quality guidelines to ensure consistent, high-quality documentation.
+
+## Features
+
+- **Section Classification System**: Categorizes manpage sections as required, recommended, optional, discouraged, or improper
+- **Content Control**: Validates content patterns, quality metrics, and structural requirements
+- **Flexible Section Names**: Supports alternative section names (e.g., "FLAGS" as alternative to "OPTIONS")
+- **Quality Enforcement**: Minimum/maximum content requirements for paragraphs, code blocks, and words
+
+## Section Classifications
+
+### Required Sections
+- **SYNOPSIS**: Brief command syntax with all options and arguments
+- **DESCRIPTION**: Detailed explanation of command purpose and functionality
+
+### Recommended Sections
+- **EXAMPLES**: Practical usage examples demonstrating common use cases
+- **OPTIONS**: Detailed option descriptions with all flags and behaviors
+- **SEE ALSO**: Related commands and documentation references
+
+### Optional Sections
+- **BUGS**: Known issues and bug reporting information
+- **AUTHORS**: Contributors and maintainers
+- **COPYRIGHT**: License information
+- **HISTORY**: Historical development information
+
+### Discouraged Sections
+- **DEPRECATED**: Legacy content (should move to HISTORY)
+- **OLD_SYNTAX**: Outdated syntax (should move to HISTORY or be removed)
+
+### Improper Sections
+- **INTERNAL_NOTES**: Development notes (must not appear in published docs)
+- **TODO**: Development tasks (remove before publication)
+- **DRAFT**: Draft markers (remove before publication)
+
+## Usage
+
+### Validating a Manpage
+
+```bash
+markitect validate my-command.1.md --schema manpage-schema-v1.0
+```
+
+### Common Validation Errors
+
+1. **Missing Required Sections**: Ensure SYNOPSIS and DESCRIPTION are present
+2. **Content Too Brief**: DESCRIPTION should have at least 50 words
+3. **No Examples**: While optional, EXAMPLES are highly recommended
+4. **Improper Sections**: Remove TODO, DRAFT, and INTERNAL_NOTES before publication
+
+## Content Quality Guidelines
+
+### SYNOPSIS Section
+- Show command name in bold: `**command**`
+- Use brackets `[]` for optional arguments
+- Use italic `*ARG*` for required arguments
+- Keep concise (1-5 lines maximum)
+- Include 5-150 words
+
+### DESCRIPTION Section
+- Start with what the command does
+- Explain why users would use it
+- Describe main functionality and features
+- Minimum 50 words, maximum 1000 words
+- At least 3 sentences
+
+### EXAMPLES Section
+- Use bash code blocks for commands
+- Include comments explaining each example
+- Start simple, progress to complex
+- Show actual output when helpful
+- Cover common use cases first
+
+## Schema Definition
+
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Enhanced Markdown Manpage Schema with Classifications",
+  "description": "JSON schema for Unix-style manual pages with section classification and content control",
+  "x-markitect-sections": {
+    "SYNOPSIS": {
+      "classification": "required",
+      "heading_level": 2,
+      "position": "after_title",
+      "content_instruction": "Brief command syntax showing all options and arguments in standard format",
+      "min_paragraphs": 1,
+      "max_paragraphs": 5,
+      "min_code_blocks": 0,
+      "max_code_blocks": 3,
+      "error_message": "SYNOPSIS section is mandatory for all manpages per Unix conventions"
+    },
+    "DESCRIPTION": {
+      "classification": "required",
+      "heading_level": 2,
+      "content_instruction": "Detailed explanation of what the command does, its purpose, and main functionality",
+      "min_paragraphs": 2,
+      "max_paragraphs": 50,
+      "error_message": "DESCRIPTION section is mandatory for all manpages"
+    },
+    "EXAMPLES": {
+      "classification": "recommended",
+      "heading_level": 2,
+      "content_instruction": "Practical usage examples with explanations demonstrating common use cases",
+      "min_code_blocks": 3,
+      "max_code_blocks": 20,
+      "warning_if_missing": "Examples greatly improve manpage usability - highly recommended"
+    },
+    "SEE ALSO": {
+      "classification": "recommended",
+      "heading_level": 2,
+      "content_instruction": "Related commands, configuration files, and documentation references",
+      "min_paragraphs": 1,
+      "warning_if_missing": "Cross-references help users discover related functionality"
+    },
+    "OPTIONS": {
+      "classification": "recommended",
+      "heading_level": 2,
+      "content_instruction": "Detailed option descriptions with all flags and their behaviors",
+      "alternatives": ["GLOBAL OPTIONS", "COMMAND OPTIONS", "FLAGS"],
+      "warning_if_missing": "Documenting command options helps users understand available functionality"
+    },
+    "BUGS": {
+      "classification": "optional",
+      "heading_level": 2,
+      "content_instruction": "Known issues, limitations, and bug reporting information"
+    },
+    "AUTHORS": {
+      "classification": "optional",
+      "heading_level": 2,
+      "content_instruction": "List of contributors and maintainers"
+    },
+    "COPYRIGHT": {
+      "classification": "optional",
+      "heading_level": 2,
+      "content_instruction": "Copyright statement and license information"
+    },
+    "HISTORY": {
+      "classification": "optional",
+      "heading_level": 2,
+      "content_instruction": "Historical information about command development"
+    },
+    "DEPRECATED": {
+      "classification": "discouraged",
+      "heading_level": 2,
+      "warning_if_missing": "Consider moving deprecated content to historical documentation or HISTORY section"
+    },
+    "OLD_SYNTAX": {
+      "classification": "discouraged",
+      "heading_level": 2,
+      "warning_if_missing": "Old syntax should be documented in HISTORY or removed entirely"
+    },
+    "INTERNAL_NOTES": {
+      "classification": "improper",
+      "heading_level": 2,
+      "error_message": "Internal notes must not appear in published manpages - move to developer documentation"
+    },
+    "TODO": {
+      "classification": "improper",
+      "heading_level": 2,
+      "error_message": "TODO sections are for development only - remove before publication"
+    },
+    "DRAFT": {
+      "classification": "improper",
+      "heading_level": 2,
+      "error_message": "DRAFT markers must be removed before publication"
+    }
+  },
+  "x-markitect-content-control": {
+    "synopsis": {
+      "required_patterns": [
+        "\\*\\*[a-z][a-z0-9-]*\\*\\*",
+        "\\[.*\\]"
+      ],
+      "discouraged_patterns": [
+        "TODO",
+        "FIXME",
+        "TBD"
+      ],
+      "content_quality": {
+        "min_words": 5,
+        "max_words": 150,
+        "readability_target": "technical"
+      },
+      "content_instructions": [
+        "Show command name in bold (e.g., **command**)",
+        "Use brackets [] for optional arguments",
+        "Use italic *ARG* for required arguments",
+        "Keep synopsis concise (1-5 lines maximum)",
+        "Use ellipsis ... to indicate repeatable arguments"
+      ]
+    },
+    "description": {
+      "discouraged_patterns": [
+        "TODO",
+        "FIXME",
+        "\\bWIP\\b",
+        "\\bXXX\\b"
+      ],
+      "forbidden_patterns": [
+        "password\\s*=\\s*[\"'].*[\"']",
+        "api[_-]?key\\s*=\\s*[\"'].*[\"']",
+        "secret\\s*=\\s*[\"'].*[\"']"
+      ],
+      "content_quality": {
+        "min_words": 50,
+        "max_words": 1000,
+        "readability_target": "technical",
+        "min_sentences": 3
+      },
+      "content_instructions": [
+        "Start with what the command does",
+        "Explain why users would use it",
+        "Describe main functionality and features",
+        "Mention any prerequisites or requirements",
+        "Keep technical but accessible"
+      ],
+      "link_validation": {
+        "check_internal": true,
+        "check_external": false,
+        "allow_fragments": true
+      }
+    },
+    "examples": {
+      "required_patterns": [
+        "```",
+        "#"
+      ],
+      "content_quality": {
+        "min_words": 100,
+        "max_words": 2000,
+        "readability_target": "general"
+      },
+      "content_instructions": [
+        "Use bash code blocks for command examples",
+        "Include comments explaining what each example does",
+        "Start with simple examples, progress to complex",
+        "Show actual output when helpful",
+        "Cover common use cases first"
+      ]
+    }
+  },
+  "type": "object",
+  "properties": {
+    "headings": {
+      "type": "object",
+      "description": "Document heading structure",
+      "properties": {
+        "level_1": {
+          "type": "array",
+          "description": "Title heading in format: command(section) - description",
+          "items": {
+            "type": "object",
+            "properties": {
+              "content": {
+                "type": "string",
+                "pattern": "^[a-z0-9-]+\\([0-9]\\) - .+"
+              }
+            }
+          },
+          "minItems": 1,
+          "maxItems": 1
+        },
+        "level_2": {
+          "type": "array",
+          "description": "Main section headings",
+          "minItems": 3,
+          "maxItems": 30
+        },
+        "level_3": {
+          "type": "array",
+          "description": "Subsection headings",
+          "minItems": 0,
+          "maxItems": 50
+        }
+      },
+      "required": ["level_1", "level_2"]
+    },
+    "paragraphs": {
+      "type": "array",
+      "description": "Text paragraphs",
+      "minItems": 10,
+      "maxItems": 500
+    },
+    "code_blocks": {
+      "type": "array",
+      "description": "Code examples",
+      "minItems": 1,
+      "maxItems": 50
+    },
+    "lists": {
+      "type": "array",
+      "description": "Lists for options and structured information",
+      "minItems": 0,
+      "maxItems": 100
+    },
+    "emphasis": {
+      "type": "array",
+      "description": "Bold and italic text for commands and arguments",
+      "minItems": 20,
+      "maxItems": 500
+    }
+  },
+  "required": ["headings", "paragraphs", "code_blocks", "emphasis"]
+}
+```
+
+## Version History
+
+### v1.0.0 (2026-01-04)
+- Initial markdown schema version
+- Migrated from enhanced-manpage JSON schema
+- Added comprehensive documentation
+- Implemented section classification system
+- Added content control and quality guidelines
+
+## Related Documentation
+
+- [Schema Naming Specification](../../roadmap/schema-of-schemas/SCHEMA_NAMING_SPEC.md)
+- [Schema Management Workplan](../../roadmap/schema-of-schemas/WORKPLAN.md)
+- [MarkiTect Documentation](../../README.md)
diff --git a/roadmap/schema-of-schemas/SCHEMA_LOADER_GUIDE.md b/roadmap/schema-of-schemas/SCHEMA_LOADER_GUIDE.md
new file mode 100644
index 00000000..782224aa
--- /dev/null
+++ b/roadmap/schema-of-schemas/SCHEMA_LOADER_GUIDE.md
@@ -0,0 +1,579 @@
+# Markdown Schema Loader - User Guide
+
+**Version:** 1.0
+**Status:** Implemented
+**Created:** 2026-01-04
+
+## Overview
+
+The Markdown Schema Loader enables MarkiTect to load JSON schemas from markdown files, combining rich documentation with machine-readable validation rules. This aligns with MarkiTect's markdown-first philosophy while maintaining JSON Schema compatibility.
+
+## Markdown Schema Format
+
+A markdown schema file consists of three parts:
+
+1. **YAML Frontmatter**: Metadata about the schema
+2. **Documentation**: Rich markdown content explaining the schema
+3. **Schema Definition**: JSON schema in a code block
+
+### Example Structure
+
+```markdown
+---
+schema-id: "https://markitect.dev/schemas/domain/v1.0"
+version: "1.0.0"
+status: "stable"
+---
+
+# Schema Title v1.0
+
+## Overview
+Description of what this schema validates...
+
+## Usage
+How to use this schema...
+
+## Schema Definition
+
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "My Schema",
+  "type": "object",
+  ...
+}
+```
+
+## Version History
+- v1.0.0 - Initial version
+```
+
+## Frontmatter Metadata
+
+### Required Fields
+
+None are strictly required, but these are recommended:
+
+| Field | Type | Description | Example |
+|-------|------|-------------|---------|
+| `schema-id` | string | Canonical URI for the schema | `https://markitect.dev/schemas/manpage/v1.0` |
+| `version` | string | SemVer version | `1.0.0` |
+| `status` | string | Lifecycle status | `stable`, `draft`, `deprecated` |
+
+### Optional Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `domain` | string | Schema domain name |
+| `description` | string | Brief schema description |
+| `authors` | array | List of authors |
+| `created` | string | Creation date (ISO 8601) |
+| `updated` | string | Last update date (ISO 8601) |
+
+### Metadata Merging
+
+Frontmatter metadata takes precedence over schema fields:
+
+- `schema-id` → `$id` in the schema
+- `version` → `version` in the schema
+- `status` → `x-markitect-metadata.status` in the schema
+
+All frontmatter is preserved in `x-markitect-source.frontmatter`.
+
+## JSON Schema Extraction
+
+### Schema Definition Section
+
+The loader prefers JSON blocks under a `## Schema Definition` heading:
+
+```markdown
+## Schema Definition
+
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  ...
+}
+```
+```
+
+### Fallback Behavior
+
+If no `## Schema Definition` section exists, the loader uses the **first** JSON code block in the file.
+
+### Multiple JSON Blocks
+
+You can include multiple JSON blocks in documentation:
+
+```markdown
+## Example Usage
+
+```json
+{
+  "name": "example",
+  "version": "1.0"
+}
+```
+
+## Schema Definition
+
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "properties": {
+    "name": {"type": "string"},
+    "version": {"type": "string"}
+  }
+}
+```
+```
+
+The loader will use the schema under `## Schema Definition` heading.
+
+## Using the Loader
+
+### Python API
+
+```python
+from pathlib import Path
+from markitect.schema_loader import MarkdownSchemaLoader
+
+# Create loader instance
+loader = MarkdownSchemaLoader()
+
+# Load schema from markdown
+schema_data = loader.load_schema(Path("manpage-schema-v1.0.md"))
+
+# Access components
+schema = schema_data['schema']         # JSON Schema dict
+metadata = schema_data['metadata']     # Frontmatter dict
+docs = schema_data['documentation']    # Full markdown content
+source = schema_data['source_file']    # Source file path
+
+# Use the schema
+print(f"Loaded: {schema['title']}")
+print(f"Version: {schema['version']}")
+print(f"Status: {metadata['status']}")
+```
+
+### Loading from Markdown
+
+```python
+# Load schema
+schema_data = loader.load_schema(Path("my-schema-v1.0.md"))
+
+# Check for issues
+issues = loader.validate_schema_structure(schema_data['schema'])
+if issues:
+    for issue in issues:
+        print(f"⚠️  {issue}")
+```
+
+### Saving to Markdown
+
+```python
+# Create a schema
+schema = {
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "My Schema",
+    "version": "1.0.0",
+    "type": "object",
+    "properties": {
+        "name": {"type": "string"}
+    }
+}
+
+# Save as markdown
+loader.save_schema(
+    schema=schema,
+    md_path=Path("my-schema-v1.0.md"),
+    frontmatter={
+        "schema-id": "https://example.com/schemas/my-schema/v1.0",
+        "status": "draft"
+    }
+)
+```
+
+### Round-Trip Conversion
+
+```python
+# Load existing JSON schema
+import json
+json_schema = json.loads(Path("old-schema.json").read_text())
+
+# Save as markdown
+loader.save_schema(
+    schema=json_schema,
+    md_path=Path("new-schema-v1.0.md")
+)
+
+# Load it back
+schema_data = loader.load_schema(Path("new-schema-v1.0.md"))
+
+# Schemas are equivalent
+assert schema_data['schema']['title'] == json_schema['title']
+```
+
+## Advanced Features
+
+### Listing JSON Blocks
+
+Useful for debugging when multiple JSON blocks exist:
+
+```python
+content = Path("schema.md").read_text()
+blocks = loader.list_json_blocks(content)
+
+print(f"Found {len(blocks)} JSON blocks:")
+for position, json_content in blocks:
+    print(f"  Position {position}: {len(json_content)} chars")
+```
+
+### Schema Structure Validation
+
+Check for recommended fields and conventions:
+
+```python
+issues = loader.validate_schema_structure(schema)
+
+for issue in issues:
+    print(f"⚠️  {issue}")
+
+# Example output:
+# ⚠️  Missing recommended field: $id
+# ⚠️  Missing MarkiTect convention: version field
+```
+
+### Custom Templates
+
+Use custom markdown templates for saving schemas:
+
+```python
+template = """---
+{frontmatter_yaml}
+---
+
+# {title}
+
+{description}
+
+## Schema
+
+```json
+{schema_json}
+```
+"""
+
+loader.save_schema(
+    schema=schema,
+    md_path=Path("custom-schema-v1.0.md"),
+    template=template
+)
+```
+
+## Error Handling
+
+### Common Errors
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `FileNotFoundError` | Schema file doesn't exist | Check file path |
+| `SchemaNotFoundError` | No JSON block in markdown | Add ```json code block |
+| `InvalidSchemaFormatError` | Invalid JSON or YAML | Check syntax |
+| `SchemaFilenameError` | Invalid filename format | Use `{domain}-schema-v{major}.{minor}.md` |
+
+### Example Error Handling
+
+```python
+from markitect.schema_loader import (
+    MarkdownSchemaLoader,
+    SchemaNotFoundError,
+    InvalidSchemaFormatError
+)
+
+loader = MarkdownSchemaLoader()
+
+try:
+    schema_data = loader.load_schema(Path("my-schema.md"))
+except FileNotFoundError as e:
+    print(f"❌ File not found: {e}")
+except SchemaNotFoundError as e:
+    print(f"❌ No schema in file: {e}")
+except InvalidSchemaFormatError as e:
+    print(f"❌ Invalid format: {e}")
+```
+
+## Best Practices
+
+### 1. Use Schema Definition Section
+
+Always place the main schema under `## Schema Definition`:
+
+```markdown
+## Schema Definition
+
+```json
+{...}
+```
+```
+
+### 2. Include Frontmatter
+
+Provide metadata for better discoverability:
+
+```yaml
+---
+schema-id: "https://markitect.dev/schemas/domain/v1.0"
+version: "1.0.0"
+status: "stable"
+---
+```
+
+### 3. Add Rich Documentation
+
+Explain the schema purpose, usage, and examples:
+
+```markdown
+## Overview
+This schema validates...
+
+## Usage
+```bash
+markitect validate doc.md --schema my-schema-v1.0
+```
+
+## Examples
+...
+```
+
+### 4. Version Your Schemas
+
+Follow the naming convention:
+
+- Initial: `my-schema-v1.0.md`
+- Minor update: `my-schema-v1.1.md`
+- Breaking change: `my-schema-v2.0.md`
+
+### 5. Validate Structure
+
+Always check for common issues:
+
+```python
+issues = loader.validate_schema_structure(schema)
+if not issues:
+    print("✅ Schema structure is valid")
+```
+
+## Integration with MarkiTect
+
+### CLI Usage (Future)
+
+Once integrated with the CLI, you'll be able to:
+
+```bash
+# Ingest markdown schema
+markitect schema-ingest manpage-schema-v1.0.md
+
+# Validate against markdown schema
+markitect validate document.md --schema manpage-schema-v1.0
+
+# Export schema
+markitect schema-get manpage-schema-v1.0 --output json
+```
+
+### Validator Integration
+
+The SchemaValidator will automatically detect `.md` schemas:
+
+```python
+from markitect.validator import SchemaValidator
+
+validator = SchemaValidator()
+validator.validate(
+    document="my-doc.md",
+    schema="manpage-schema-v1.0.md"  # .md extension auto-detected
+)
+```
+
+## Markdown Schema Template
+
+Here's a complete template for creating new schemas:
+
+```markdown
+---
+schema-id: "https://markitect.dev/schemas/YOUR-DOMAIN/v1.0"
+version: "1.0.0"
+status: "draft"
+domain: "YOUR-DOMAIN"
+description: "Brief description of what this schema validates"
+authors:
+  - "Your Name <email@example.com>"
+created: "2026-01-04"
+---
+
+# YOUR-DOMAIN Schema v1.0
+
+## Overview
+
+Detailed description of what this schema validates and why it exists.
+
+## Features
+
+- Feature 1
+- Feature 2
+- Feature 3
+
+## Usage
+
+### Validating Documents
+
+```bash
+markitect validate document.md --schema YOUR-DOMAIN-schema-v1.0
+```
+
+### Common Validation Errors
+
+1. **Error Type 1**: Description and solution
+2. **Error Type 2**: Description and solution
+
+## Schema Definition
+
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "YOUR DOMAIN Schema",
+  "description": "Schema description",
+  "type": "object",
+  "properties": {
+    "field1": {
+      "type": "string",
+      "description": "Description of field1"
+    }
+  },
+  "required": ["field1"]
+}
+```
+
+## Examples
+
+### Valid Document
+
+```markdown
+Example of valid content...
+```
+
+### Invalid Document
+
+```markdown
+Example of invalid content...
+```
+
+## Version History
+
+### v1.0.0 (2026-01-04)
+- Initial version
+- Feature A
+- Feature B
+
+## Related Documentation
+
+- [Related Schema 1](../other-schema-v1.0.md)
+- [MarkiTect Documentation](../../README.md)
+```
+
+## Testing
+
+The loader has comprehensive test coverage:
+
+```bash
+# Run all loader tests
+pytest tests/test_schema_loader.py -v
+
+# Run specific test class
+pytest tests/test_schema_loader.py::TestMarkdownSchemaLoader -v
+
+# Check coverage
+pytest tests/test_schema_loader.py --cov=markitect.schema_loader
+```
+
+**Test Results**: 35/35 tests passing (100%)
+
+## Implementation Details
+
+### Regex Patterns
+
+The loader uses these regex patterns:
+
+```python
+# Frontmatter pattern
+r'^---\s*\n(.*?)\n---\s*\n'
+
+# JSON code block pattern
+r'```json\s*\n(.*?)\n```'
+
+# Schema Definition section pattern
+r'##\s+Schema Definition\s*\n'
+```
+
+### Metadata Merging
+
+The `_merge_metadata` method:
+
+1. Copies the original schema
+2. Adds `x-markitect-source` with file metadata
+3. Merges frontmatter fields:
+   - `schema-id` → `$id`
+   - `version` → `version`
+   - `status` → `x-markitect-metadata.status`
+
+### File Encoding
+
+All files are read/written as UTF-8. Invalid UTF-8 sequences raise `InvalidSchemaFormatError`.
+
+## Troubleshooting
+
+### Schema Not Found
+
+**Problem**: `SchemaNotFoundError: No JSON schema found`
+
+**Solutions**:
+- Ensure you have a ```json code block
+- Check the JSON syntax is valid
+- Verify the code block is properly closed with ```
+
+### Invalid YAML Frontmatter
+
+**Problem**: `InvalidSchemaFormatError: Invalid YAML frontmatter`
+
+**Solutions**:
+- Check YAML syntax (indentation, colons, quotes)
+- Ensure frontmatter is between `---` delimiters
+- Verify frontmatter is at the start of file
+
+### Binary File Error
+
+**Problem**: `InvalidSchemaFormatError: Failed to read schema file`
+
+**Solutions**:
+- Ensure file is text, not binary
+- Check file encoding is UTF-8
+- Verify file isn't corrupted
+
+## See Also
+
+- [Schema Naming Specification](SCHEMA_NAMING_SPEC.md)
+- [Schema Management Workplan](WORKPLAN.md)
+- [Phase 2 Documentation](WORKPLAN.md#phase-2-markdown-schema-loader)
+- [Example Markdown Schema](../../markitect/schemas/manpage-schema-v1.0.md)
+
+## Changelog
+
+### v1.0.0 (2026-01-04)
+- Initial implementation
+- 35 unit tests (100% passing)
+- Frontmatter extraction with YAML parsing
+- JSON code block extraction with section preference
+- Metadata merging with x-markitect-source tracking
+- Schema saving with template support
+- Round-trip save/load capability
+- Helper methods for validation and debugging
diff --git a/tests/test_schema_loader.py b/tests/test_schema_loader.py
new file mode 100644
index 00000000..f840cf53
--- /dev/null
+++ b/tests/test_schema_loader.py
@@ -0,0 +1,688 @@
+"""
+Unit tests for schema_loader.py - Markdown schema loading.
+
+Tests the markdown schema loader functionality including:
+- Frontmatter extraction (YAML)
+- JSON schema extraction from code blocks
+- Metadata merging
+- Schema saving
+- Error handling
+"""
+
+import pytest
+import json
+import yaml
+from pathlib import Path
+from markitect.schema_loader import (
+    MarkdownSchemaLoader,
+    SchemaLoaderError,
+    InvalidSchemaFormatError,
+    SchemaNotFoundError
+)
+
+
+# Test fixtures
+
+@pytest.fixture
+def temp_schema_dir(tmp_path):
+    """Create temporary directory for schema files."""
+    schema_dir = tmp_path / "schemas"
+    schema_dir.mkdir()
+    return schema_dir
+
+
+@pytest.fixture
+def simple_schema_md():
+    """Simple valid markdown schema content."""
+    return """---
+schema-id: "https://markitect.dev/schemas/test/v1"
+version: "1.0.0"
+status: "stable"
+---
+
+# Test Schema v1.0
+
+## Overview
+
+This is a test schema for validation.
+
+## Schema Definition
+
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://markitect.dev/schemas/test/v1",
+  "version": "1.0.0",
+  "title": "Test Schema",
+  "description": "Schema for testing",
+  "type": "object",
+  "properties": {
+    "name": {"type": "string"}
+  }
+}
+```
+
+## Version History
+
+### v1.0.0
+- Initial version
+"""
+
+
+@pytest.fixture
+def schema_without_frontmatter():
+    """Schema without YAML frontmatter."""
+    return """# Test Schema v1.0
+
+## Schema Definition
+
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Test Schema",
+  "type": "object"
+}
+```
+"""
+
+
+@pytest.fixture
+def schema_multiple_json_blocks():
+    """Schema with multiple JSON code blocks."""
+    return """---
+version: "1.0.0"
+---
+
+# Test Schema
+
+## Example Usage
+
+```json
+{
+  "example": "This is not the schema"
+}
+```
+
+## Schema Definition
+
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Test Schema",
+  "type": "object"
+}
+```
+
+## More Examples
+
+```json
+{
+  "another": "example"
+}
+```
+"""
+
+
+class TestMarkdownSchemaLoader:
+    """Tests for MarkdownSchemaLoader class."""
+
+    def test_init(self):
+        """Test loader initialization."""
+        loader = MarkdownSchemaLoader()
+        assert loader is not None
+        assert hasattr(loader, 'frontmatter_pattern')
+        assert hasattr(loader, 'json_code_block_pattern')
+
+    def test_load_simple_schema(self, temp_schema_dir, simple_schema_md):
+        """Test loading a simple valid schema."""
+        schema_file = temp_schema_dir / "test-schema-v1.0.md"
+        schema_file.write_text(simple_schema_md)
+
+        loader = MarkdownSchemaLoader()
+        result = loader.load_schema(schema_file)
+
+        assert 'schema' in result
+        assert 'metadata' in result
+        assert 'documentation' in result
+        assert 'source_file' in result
+
+        # Check schema content
+        schema = result['schema']
+        assert schema['title'] == 'Test Schema'
+        assert schema['version'] == '1.0.0'
+        assert schema['type'] == 'object'
+
+        # Check metadata
+        metadata = result['metadata']
+        assert metadata['version'] == '1.0.0'
+        assert metadata['status'] == 'stable'
+
+        # Check source tracking
+        assert result['source_file'] == str(schema_file)
+        assert 'x-markitect-source' in schema
+        assert schema['x-markitect-source']['format'] == 'markdown'
+
+    def test_load_schema_file_not_found(self):
+        """Test loading non-existent file raises FileNotFoundError."""
+        loader = MarkdownSchemaLoader()
+
+        with pytest.raises(FileNotFoundError, match="Schema file not found"):
+            loader.load_schema(Path("/nonexistent/schema.md"))
+
+    def test_load_schema_without_json(self, temp_schema_dir):
+        """Test loading markdown without JSON schema raises error."""
+        schema_file = temp_schema_dir / "no-schema.md"
+        schema_file.write_text("# Just a heading\n\nNo schema here.")
+
+        loader = MarkdownSchemaLoader()
+
+        with pytest.raises(SchemaNotFoundError, match="No JSON schema found"):
+            loader.load_schema(schema_file)
+
+    def test_load_schema_invalid_json(self, temp_schema_dir):
+        """Test loading markdown with invalid JSON raises error."""
+        content = """# Test
+
+```json
+{invalid json}
+```
+"""
+        schema_file = temp_schema_dir / "invalid.md"
+        schema_file.write_text(content)
+
+        loader = MarkdownSchemaLoader()
+
+        with pytest.raises(InvalidSchemaFormatError, match="Invalid JSON"):
+            loader.load_schema(schema_file)
+
+
+class TestExtractFrontmatter:
+    """Tests for frontmatter extraction."""
+
+    def test_extract_valid_frontmatter(self, simple_schema_md):
+        """Test extracting valid YAML frontmatter."""
+        loader = MarkdownSchemaLoader()
+        metadata = loader._extract_frontmatter(simple_schema_md)
+
+        assert metadata['schema-id'] == 'https://markitect.dev/schemas/test/v1'
+        assert metadata['version'] == '1.0.0'
+        assert metadata['status'] == 'stable'
+
+    def test_extract_no_frontmatter(self, schema_without_frontmatter):
+        """Test extracting from content without frontmatter returns empty dict."""
+        loader = MarkdownSchemaLoader()
+        metadata = loader._extract_frontmatter(schema_without_frontmatter)
+
+        assert metadata == {}
+
+    def test_extract_invalid_yaml_frontmatter(self):
+        """Test extracting invalid YAML raises error."""
+        content = """---
+invalid: yaml: syntax: error
+---
+
+# Content
+"""
+        loader = MarkdownSchemaLoader()
+
+        with pytest.raises(InvalidSchemaFormatError, match="Invalid YAML"):
+            loader._extract_frontmatter(content)
+
+    def test_extract_non_dict_frontmatter(self):
+        """Test extracting non-dictionary YAML raises error."""
+        content = """---
+- list
+- not
+- dict
+---
+
+# Content
+"""
+        loader = MarkdownSchemaLoader()
+
+        with pytest.raises(InvalidSchemaFormatError, match="must be a YAML dictionary"):
+            loader._extract_frontmatter(content)
+
+    def test_extract_complex_frontmatter(self):
+        """Test extracting complex frontmatter with nested structures."""
+        content = """---
+schema-id: "https://example.com/schema"
+version: "1.0.0"
+tags:
+  - documentation
+  - schema
+metadata:
+  author: "Test Author"
+  created: "2026-01-04"
+---
+
+# Content
+"""
+        loader = MarkdownSchemaLoader()
+        metadata = loader._extract_frontmatter(content)
+
+        assert metadata['tags'] == ['documentation', 'schema']
+        assert metadata['metadata']['author'] == 'Test Author'
+
+
+class TestExtractJsonSchema:
+    """Tests for JSON schema extraction."""
+
+    def test_extract_single_json_block(self, schema_without_frontmatter):
+        """Test extracting single JSON block."""
+        loader = MarkdownSchemaLoader()
+        schema = loader._extract_json_schema(schema_without_frontmatter)
+
+        assert schema is not None
+        assert schema['title'] == 'Test Schema'
+        assert schema['type'] == 'object'
+
+    def test_extract_from_schema_definition_section(self, schema_multiple_json_blocks):
+        """Test preferring JSON block under Schema Definition heading."""
+        loader = MarkdownSchemaLoader()
+        schema = loader._extract_json_schema(schema_multiple_json_blocks)
+
+        assert schema is not None
+        assert schema['title'] == 'Test Schema'
+        # Should get the schema from Schema Definition section, not the example
+
+    def test_extract_no_json_block(self):
+        """Test extracting from content with no JSON blocks returns None."""
+        content = "# Just text\n\nNo code blocks here."
+        loader = MarkdownSchemaLoader()
+        schema = loader._extract_json_schema(content)
+
+        assert schema is None
+
+    def test_extract_invalid_json_block(self):
+        """Test extracting invalid JSON raises error."""
+        content = """# Test
+
+```json
+{invalid}
+```
+"""
+        loader = MarkdownSchemaLoader()
+
+        with pytest.raises(InvalidSchemaFormatError, match="Invalid JSON"):
+            loader._extract_json_schema(content)
+
+    def test_extract_non_object_json(self):
+        """Test extracting JSON array (non-object) raises error."""
+        content = """# Test
+
+```json
+["array", "not", "object"]
+```
+"""
+        loader = MarkdownSchemaLoader()
+
+        with pytest.raises(InvalidSchemaFormatError, match="must be a JSON object"):
+            loader._extract_json_schema(content)
+
+
+class TestMergeMetadata:
+    """Tests for metadata merging."""
+
+    def test_merge_basic_metadata(self):
+        """Test merging frontmatter into schema."""
+        loader = MarkdownSchemaLoader()
+
+        schema = {
+            'title': 'Test Schema',
+            'type': 'object'
+        }
+
+        metadata = {
+            'version': '2.0.0',
+            'schema-id': 'https://example.com/v2',
+            'status': 'draft'
+        }
+
+        merged = loader._merge_metadata(schema, metadata, Path('test.md'))
+
+        # Version should be overridden
+        assert merged['version'] == '2.0.0'
+
+        # $id should be set from schema-id
+        assert merged['$id'] == 'https://example.com/v2'
+
+        # Status should be in x-markitect-metadata
+        assert merged['x-markitect-metadata']['status'] == 'draft'
+
+        # Source tracking should be added
+        assert merged['x-markitect-source']['file'] == 'test.md'
+        assert merged['x-markitect-source']['format'] == 'markdown'
+
+    def test_merge_preserves_schema_fields(self):
+        """Test merging doesn't remove existing schema fields."""
+        loader = MarkdownSchemaLoader()
+
+        schema = {
+            'title': 'Test',
+            'type': 'object',
+            'properties': {'name': {'type': 'string'}}
+        }
+
+        merged = loader._merge_metadata(schema, {}, Path('test.md'))
+
+        assert merged['title'] == 'Test'
+        assert merged['type'] == 'object'
+        assert 'properties' in merged
+
+    def test_merge_frontmatter_takes_precedence(self):
+        """Test frontmatter overrides schema values."""
+        loader = MarkdownSchemaLoader()
+
+        schema = {
+            'version': '1.0.0',
+            '$id': 'old-id'
+        }
+
+        metadata = {
+            'version': '2.0.0',
+            'schema-id': 'new-id'
+        }
+
+        merged = loader._merge_metadata(schema, metadata, Path('test.md'))
+
+        assert merged['version'] == '2.0.0'
+        assert merged['$id'] == 'new-id'
+
+
+class TestSaveSchema:
+    """Tests for saving schemas to markdown."""
+
+    def test_save_simple_schema(self, temp_schema_dir):
+        """Test saving a schema to markdown file."""
+        loader = MarkdownSchemaLoader()
+
+        schema = {
+            '$schema': 'http://json-schema.org/draft-07/schema#',
+            '$id': 'https://example.com/schema/v1',
+            'version': '1.0.0',
+            'title': 'Test Schema',
+            'description': 'A test schema',
+            'type': 'object'
+        }
+
+        output_file = temp_schema_dir / 'output-schema-v1.0.md'
+        loader.save_schema(schema, output_file)
+
+        assert output_file.exists()
+
+        # Verify content
+        content = output_file.read_text()
+        assert '---' in content  # Frontmatter
+        assert 'Test Schema v1.0.0' in content  # Title
+        assert '```json' in content  # JSON block
+        assert '"title": "Test Schema"' in content
+
+    def test_save_creates_parent_directory(self, temp_schema_dir):
+        """Test saving creates parent directories if needed."""
+        loader = MarkdownSchemaLoader()
+
+        schema = {'title': 'Test', 'type': 'object'}
+        output_file = temp_schema_dir / 'nested' / 'dir' / 'schema.md'
+
+        loader.save_schema(schema, output_file)
+
+        assert output_file.exists()
+        assert output_file.parent.exists()
+
+    def test_save_with_custom_frontmatter(self, temp_schema_dir):
+        """Test saving with custom frontmatter."""
+        loader = MarkdownSchemaLoader()
+
+        schema = {'title': 'Test', 'type': 'object'}
+        frontmatter = {
+            'schema-id': 'https://custom.com/schema',
+            'status': 'experimental',
+            'tags': ['test', 'custom']
+        }
+
+        output_file = temp_schema_dir / 'custom.md'
+        loader.save_schema(schema, output_file, frontmatter=frontmatter)
+
+        content = output_file.read_text()
+        assert 'experimental' in content
+        assert 'https://custom.com/schema' in content
+
+    def test_save_and_reload_roundtrip(self, temp_schema_dir):
+        """Test saving and reloading produces same schema."""
+        loader = MarkdownSchemaLoader()
+
+        original_schema = {
+            '$schema': 'http://json-schema.org/draft-07/schema#',
+            'version': '1.0.0',
+            'title': 'Roundtrip Test',
+            'type': 'object',
+            'properties': {
+                'name': {'type': 'string'},
+                'age': {'type': 'integer'}
+            }
+        }
+
+        schema_file = temp_schema_dir / 'roundtrip-schema-v1.0.md'
+        loader.save_schema(original_schema, schema_file)
+
+        # Reload
+        loaded = loader.load_schema(schema_file)
+        loaded_schema = loaded['schema']
+
+        # Compare key fields (ignoring x-markitect-source added during load)
+        assert loaded_schema['title'] == original_schema['title']
+        assert loaded_schema['type'] == original_schema['type']
+        assert loaded_schema['properties'] == original_schema['properties']
+
+
+class TestGenerateMarkdown:
+    """Tests for markdown generation."""
+
+    def test_generate_basic_markdown(self):
+        """Test generating basic markdown from schema."""
+        loader = MarkdownSchemaLoader()
+
+        schema = {
+            'title': 'Test Schema',
+            'version': '1.0.0',
+            'description': 'Test description',
+            'type': 'object'
+        }
+
+        md = loader._generate_markdown(schema)
+
+        assert 'Test Schema v1.0.0' in md
+        assert 'Test description' in md
+        assert '```json' in md
+        assert '"title": "Test Schema"' in md
+        assert '---' in md  # Frontmatter
+
+    def test_generate_includes_frontmatter(self):
+        """Test generated markdown includes frontmatter."""
+        loader = MarkdownSchemaLoader()
+
+        schema = {
+            '$id': 'https://example.com/schema',
+            'title': 'Test',
+            'version': '2.0.0',
+            'type': 'object'
+        }
+
+        md = loader._generate_markdown(schema)
+
+        # Parse frontmatter
+        lines = md.split('\n')
+        assert lines[0] == '---'
+
+        # Find end of frontmatter
+        end_idx = lines[1:].index('---') + 1
+
+        frontmatter_yaml = '\n'.join(lines[1:end_idx])
+        frontmatter = yaml.safe_load(frontmatter_yaml)
+
+        assert frontmatter['version'] == '2.0.0'
+        assert frontmatter['schema-id'] == 'https://example.com/schema'
+
+
+class TestListJsonBlocks:
+    """Tests for listing JSON blocks."""
+
+    def test_list_single_block(self, schema_without_frontmatter):
+        """Test listing single JSON block."""
+        loader = MarkdownSchemaLoader()
+        blocks = loader.list_json_blocks(schema_without_frontmatter)
+
+        assert len(blocks) == 1
+        assert '"title": "Test Schema"' in blocks[0][1]
+
+    def test_list_multiple_blocks(self, schema_multiple_json_blocks):
+        """Test listing multiple JSON blocks."""
+        loader = MarkdownSchemaLoader()
+        blocks = loader.list_json_blocks(schema_multiple_json_blocks)
+
+        assert len(blocks) == 3
+        # First block
+        assert '"example"' in blocks[0][1]
+        # Second block (schema)
+        assert '"title": "Test Schema"' in blocks[1][1]
+        # Third block
+        assert '"another"' in blocks[2][1]
+
+    def test_list_no_blocks(self):
+        """Test listing with no JSON blocks."""
+        loader = MarkdownSchemaLoader()
+        blocks = loader.list_json_blocks("# Just text\n\nNo code blocks.")
+
+        assert len(blocks) == 0
+
+
+class TestValidateSchemaStructure:
+    """Tests for schema structure validation."""
+
+    def test_validate_complete_schema(self):
+        """Test validating complete schema returns no issues."""
+        loader = MarkdownSchemaLoader()
+
+        schema = {
+            '$schema': 'http://json-schema.org/draft-07/schema#',
+            '$id': 'https://example.com/schema',
+            'version': '1.0.0',
+            'title': 'Test Schema',
+            'description': 'Test description',
+            'type': 'object'
+        }
+
+        issues = loader.validate_schema_structure(schema)
+        assert len(issues) == 0
+
+    def test_validate_missing_required_fields(self):
+        """Test validation detects missing required fields."""
+        loader = MarkdownSchemaLoader()
+
+        schema = {'type': 'object'}
+
+        issues = loader.validate_schema_structure(schema)
+
+        assert len(issues) > 0
+        assert any('$schema' in issue for issue in issues)
+        assert any('title' in issue for issue in issues)
+        assert any('description' in issue for issue in issues)
+
+    def test_validate_missing_version(self):
+        """Test validation detects missing version field."""
+        loader = MarkdownSchemaLoader()
+
+        schema = {
+            '$schema': 'http://json-schema.org/draft-07/schema#',
+            'title': 'Test',
+            'type': 'object'
+        }
+
+        issues = loader.validate_schema_structure(schema)
+
+        assert any('version' in issue for issue in issues)
+
+    def test_validate_invalid_id_format(self):
+        """Test validation detects non-HTTPS $id."""
+        loader = MarkdownSchemaLoader()
+
+        schema = {
+            '$schema': 'http://json-schema.org/draft-07/schema#',
+            '$id': 'http://example.com/schema',  # HTTP not HTTPS
+            'version': '1.0.0',
+            'title': 'Test',
+            'type': 'object'
+        }
+
+        issues = loader.validate_schema_structure(schema)
+
+        assert any('HTTPS' in issue for issue in issues)
+
+
+class TestEdgeCases:
+    """Tests for edge cases and error conditions."""
+
+    def test_load_empty_file(self, temp_schema_dir):
+        """Test loading empty file raises error."""
+        schema_file = temp_schema_dir / 'empty.md'
+        schema_file.write_text('')
+
+        loader = MarkdownSchemaLoader()
+
+        with pytest.raises(SchemaNotFoundError):
+            loader.load_schema(schema_file)
+
+    def test_load_binary_file(self, temp_schema_dir):
+        """Test loading binary file with invalid UTF-8 raises error."""
+        schema_file = temp_schema_dir / 'binary.md'
+        # Use invalid UTF-8 sequences that will trigger UnicodeDecodeError
+        schema_file.write_bytes(b'\xff\xfe\x00\x00\x80\x81\x82')
+
+        loader = MarkdownSchemaLoader()
+
+        with pytest.raises(InvalidSchemaFormatError):
+            loader.load_schema(schema_file)
+
+    def test_malformed_code_block(self, temp_schema_dir):
+        """Test handling malformed code block delimiters."""
+        content = """# Test
+
+```json
+{"valid": "json"
+# Missing closing backticks
+"""
+        schema_file = temp_schema_dir / 'malformed.md'
+        schema_file.write_text(content)
+
+        loader = MarkdownSchemaLoader()
+
+        with pytest.raises(SchemaNotFoundError):
+            loader.load_schema(schema_file)
+
+    def test_very_large_schema(self, temp_schema_dir):
+        """Test loading very large schema."""
+        # Create large schema with many properties
+        large_schema = {
+            '$schema': 'http://json-schema.org/draft-07/schema#',
+            'title': 'Large Schema',
+            'type': 'object',
+            'properties': {
+                f'prop_{i}': {'type': 'string'}
+                for i in range(1000)
+            }
+        }
+
+        content = f"""# Large Schema
+
+```json
+{json.dumps(large_schema, indent=2)}
+```
+"""
+        schema_file = temp_schema_dir / 'large.md'
+        schema_file.write_text(content)
+
+        loader = MarkdownSchemaLoader()
+        result = loader.load_schema(schema_file)
+
+        assert len(result['schema']['properties']) == 1000