diff --git a/ENHANCEMENT_SUMMARY.md b/ENHANCEMENT_SUMMARY.md
new file mode 100644
index 0000000..a25ec7c
--- /dev/null
+++ b/ENHANCEMENT_SUMMARY.md
@@ -0,0 +1,201 @@
+# Python Template Enhancement Summary
+
+## Overview
+
+Successfully completed comprehensive enhancement of the Python cookiecutter template, transforming it from a basic project generator into an enterprise-grade, flexible, and secure foundation for Python projects.
+
+## New Features Implemented
+
+### 1. Advanced Input Validation (pre_gen_project.py)
+- Validates package names as Python identifiers
+- Prevents reserved name conflicts
+- Normalizes project slugs
+- Validates project types and package managers
+- Clear error messages with helpful tips
+
+### 2. Expanded Configuration Options
+```json
+{
+  "project_type": ["library", "cli-application"],
+  "package_manager": ["pip", "uv", "hatch"], 
+  "docs": ["y", "n"],
+  "typed_config": ["n", "y"],
+  "sbom": ["n", "y"],
+  "versioning": ["setuptools-scm", "manual", "hatch"]
+}
+```
+
+### 3. Package Manager Support
+- **pip**: Traditional dependency management
+- **uv**: Ultra-fast package installer with optimized CI configs
+- **hatch**: Modern project manager with advanced features
+- Conditional pyproject.toml configuration for each manager
+
+### 4. Typed Configuration System
+- Optional Pydantic-based settings with validation
+- Environment variable loading with proper prefixes
+- Type hints and IDE autocompletion support
+- Backward compatibility with traditional config system
+- Comprehensive validation and error messages
+
+### 5. Enhanced Logging & Observability
+- JSON-first logging with structured output
+- Request/operation ID tracking using context variables
+- Context managers for correlation ID management
+- Thread-safe logging with performance optimizations
+- Centralized sensitive data filtering
+
+### 6. Supply Chain Security
+- SBOM generation with CycloneDX and SPDX formats
+- Cryptographic attestation for releases
+- Dependency auditing with pip-audit integration
+- Vulnerability scanning in CI pipelines
+- Automated security updates via Dependabot
+
+### 7. Enhanced CI/CD
+- Multi-OS testing (Ubuntu + Windows)
+- Multi-Python version matrix (3.11, 3.12, 3.13)
+- Package manager-aware dependency installation
+- Security auditing in every build
+- Codecov integration for coverage tracking
+
+### 8. Comprehensive Documentation
+- Optional MkDocs with Material theme
+- Auto-generated API documentation
+- Conditional documentation pages for configuration and CLI usage
+- GitHub Pages deployment workflow
+- Professional documentation structure
+
+### 9. Release Automation
+- Release Drafter with conventional commits
+- Automated changelog generation
+- Semantic versioning with proper categorization
+- GitHub release automation
+
+## Testing Results
+
+### Template Validation Matrix
+Successfully tested 6 different combinations:
+
+1. **library-pip-basic**: Minimal library with pip
+2. **library-pip-full**: Full-featured library with all options
+3. **cli-uv-basic**: CLI app with uv package manager
+4. **cli-hatch-full**: CLI app with Hatch and all features
+5. **library-uv-typed**: Library with typed config and docs
+6. **cli-pip-sbom**: CLI app with SBOM generation
+
+### Functionality Verification
+- ✅ All imports work correctly
+- ✅ Typed configuration loads and validates
+- ✅ Enhanced logging with request IDs functions
+- ✅ Context management for correlation IDs works
+- ✅ Conditional file generation operates properly
+- ✅ Package manager configurations are correct
+
+## Project Impact
+
+### Before Enhancement
+- Basic project structure
+- Simple configuration system
+- Standard logging
+- Limited CI/CD
+- Minimal security features
+- No package manager choice
+- Basic documentation
+
+### After Enhancement
+- Enterprise-grade security and compliance
+- Flexible package management (pip/uv/hatch)
+- Type-safe configuration with Pydantic
+- Advanced observability with correlation IDs
+- Multi-environment CI/CD with comprehensive testing
+- Supply chain security with SBOM generation
+- Professional documentation with auto-deployment
+- Zero-configuration developer experience
+
+## Technical Achievements
+
+### Architecture Improvements
+- Modular template design with conditional features
+- Backward compatibility preservation
+- Clean separation of concerns
+- Extensible configuration system
+
+### Security Enhancements
+- Supply chain security compliance
+- Automated vulnerability scanning
+- Sensitive data protection
+- Security workflow automation
+
+### Developer Experience
+- Zero configuration required
+- Choose only needed features
+- Professional tooling out-of-the-box
+- Comprehensive documentation
+
+### Maintenance & Quality
+- Automated dependency updates
+- Quality gates enforcement
+- Multi-environment testing
+- Release automation
+
+## Usage Examples
+
+### Minimal Setup
+```bash
+cookiecutter https://github.com/retr0crypticghost/python-template.git \
+  --no-input project_type="library" package_manager="pip" \
+  docs="n" typed_config="n" sbom="n"
+```
+
+### Enterprise Setup
+```bash
+cookiecutter https://github.com/retr0crypticghost/python-template.git \
+  --no-input project_type="cli-application" package_manager="uv" \
+  docs="y" typed_config="y" sbom="y" versioning="setuptools-scm"
+```
+
+## Files Modified/Created
+
+### New Files
+- `hooks/pre_gen_project.py` - Input validation
+- `{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/settings.py` - Typed config
+- `{{cookiecutter.project_slug}}/tests/test_settings.py` - Typed config tests  
+- `{{cookiecutter.project_slug}}/.github/workflows/sbom.yml` - SBOM generation
+- `{{cookiecutter.project_slug}}/.github/workflows/release-drafter.yml` - Release automation
+- `{{cookiecutter.project_slug}}/.github/release-drafter.yml` - Release config
+- `{{cookiecutter.project_slug}}/docs/configuration.md` - Config documentation
+- `{{cookiecutter.project_slug}}/docs/cli-usage.md` - CLI documentation
+
+### Enhanced Files
+- `cookiecutter.json` - New options and cleanup
+- `hooks/post_gen_project.py` - Conditional file management
+- `{{cookiecutter.project_slug}}/pyproject.toml` - Package manager support
+- `{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/config.py` - Typed config integration
+- `{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/logger.py` - Enhanced logging
+- `{{cookiecutter.project_slug}}/.github/workflows/ci.yml` - Enhanced CI/CD
+- `{{cookiecutter.project_slug}}/.github/workflows/docs.yml` - Conditional docs
+- `{{cookiecutter.project_slug}}/mkdocs.yml` - Enhanced documentation
+- `test_template.sh` - Comprehensive testing
+- `README.md` - Complete documentation update
+
+## Future Considerations
+
+The template is now production-ready with enterprise-grade features. Future enhancements could include:
+- Additional project types (web-api, data-science) when needed
+- More package managers if they gain traction
+- Additional security compliance frameworks
+- Enhanced monitoring and observability features
+
+## Conclusion
+
+The Python cookiecutter template has been successfully transformed into a comprehensive, enterprise-grade foundation that provides:
+
+1. **Flexibility** - Choose only the features you need
+2. **Security** - Enterprise-grade security and compliance built-in
+3. **Quality** - Professional tooling and quality gates
+4. **Productivity** - Zero configuration, everything works out-of-the-box
+5. **Maintainability** - Automated updates and maintenance
+6. **Observability** - Built-in logging and monitoring capabilities
+
+The template now serves as a professional foundation for Python projects of any scale, from simple libraries to enterprise applications.
\ No newline at end of file
diff --git a/README.md b/README.md
index d71e3f5..3197296 100644
--- a/README.md
+++ b/README.md
@@ -18,33 +18,55 @@ A [Cookiecutter](https://github.com/cookiecutter/cookiecutter) template for Pyth
 
 ## What This Template Provides
 
-This template generates projects with professional patterns and good security practices:
+This template generates projects with professional patterns, modern tooling, and comprehensive security practices:
 
-### 🔒 Security-Conscious Logging
+### 🔒 Security-First Design
 
 - **Sensitive data filtering**: Automatically masks passwords, tokens, and secrets in logs
-- **Thread-safe logging**: Safe for concurrent operations
-- **Structured output**: Consistent formatting for both development and production
-- **Audit capabilities**: Security event tracking when needed
+- **Supply chain security**: SBOM generation, dependency scanning, and vulnerability auditing  
+- **Security workflows**: CodeQL analysis, OpenSSF Scorecard, and automated security updates
+- **Audit capabilities**: Security event tracking and compliance logging
 
-### ⚙️ Hierarchical Configuration
+### ⚙️ Advanced Configuration Management
 
-- **Precedence system**: Environment variables → Config file → Defaults
-- **Type safety**: Automatic conversion and validation of configuration values
-- **Multiple formats**: YAML and JSON support with auto-detection
+- **Multiple package managers**: pip, uv, or Hatch support with optimized configurations
+- **Typed configuration**: Optional Pydantic-based settings with validation and IDE support
+- **Hierarchical loading**: Environment variables → Config file → Defaults
 - **Environment validation**: Startup checks for required configuration
 
-### 🧪 Comprehensive Testing
+### 📊 Enhanced Logging & Observability
 
-- **pytest foundation**: Ready-to-use testing setup with helpful fixtures
-- **Coverage requirements**: 90%+ coverage enforcement to maintain quality
-- **Security testing**: Patterns for testing sensitive data handling
-- **CI/CD integration**: GitHub Actions with multi-Python version testing
+- **JSON-first logging**: Structured logging with request/operation ID tracking
+- **Context management**: Automatic correlation IDs for distributed tracing
+- **Thread-safe logging**: Safe for concurrent operations with performance optimizations
+- **Flexible formats**: Switch between JSON and plain text as needed
+
+### 🧪 Comprehensive Testing & Quality
+
+- **Multi-environment CI**: Tests on Ubuntu and Windows with multiple Python versions
+- **Security testing**: Patterns for testing sensitive data handling and configuration
+- **Coverage enforcement**: 90%+ coverage requirements with quality gates
+- **Type safety**: mypy integration with graduated strictness levels
 
 ### 🚀 Professional Project Types
 
-**📚 Library Projects**: Clean package structure with modern packaging standards
-**⚡ CLI Applications**: Rich command-line interface with shell completion and documentation
+**📚 Library Projects**: Clean package structure with modern packaging standards and comprehensive documentation
+
+**⚡ CLI Applications**: Rich command-line interface with shell completion, man page generation, and professional help systems
+
+### 🛡️ Supply Chain Security
+
+- **SBOM generation**: Automatic Software Bill of Materials in CycloneDX and SPDX formats
+- **Dependency auditing**: Integrated pip-audit scanning in CI workflows  
+- **Vulnerability monitoring**: Automated dependency updates and security advisories
+- **Attestation support**: Cryptographic verification of build artifacts
+
+### 📖 Documentation & Developer Experience
+
+- **Optional MkDocs**: Material theme with automatic GitHub Pages deployment
+- **API documentation**: Auto-generated from docstrings with mkdocstrings
+- **Configuration docs**: Auto-generated documentation for typed config schemas
+- **CLI documentation**: Comprehensive usage guides and examples
 
 > **Why these features?** These are patterns I've developed through building Python projects for business use. They solve real problems around configuration management, security compliance, and professional tooling expectations.
 
@@ -75,6 +97,11 @@ package_name [data_analysis_tool]:
 project_description [A brief description of your project]: Tool for analyzing research data
 python_version [3.11]:
 project_type [library]: cli-application
+package_manager [pip]: uv
+docs [y]: y
+typed_config [n]: y
+sbom [n]: y
+versioning [setuptools-scm]: setuptools-scm
 author_name [Your Name]: retr0crypticghost
 author_email [your.email@example.com]: retr0@example.com
 github_username [your-username]: retr0crypticghost
@@ -84,7 +111,95 @@ include_pre_commit [y]: y
 license [MIT]:
 ```
 
-**Result**: A fully-configured Python project with security practices, testing setup, and professional tooling ready for development.
+**Result**: A fully-configured Python project with your chosen features, security practices, testing setup, and professional tooling ready for development.
+
+## Configuration Options
+
+The template now supports comprehensive customization:
+
+### Project Types
+- **`library`** - Python package for reusable components
+- **`cli-application`** - Command-line tool with Rich interface
+
+### Package Managers
+- **`pip`** - Traditional pip-based dependency management
+- **`uv`** - Ultra-fast Python package installer (recommended for speed)
+- **`hatch`** - Modern Python project manager with advanced features
+
+### Documentation
+- **`docs=y`** - Scaffolds MkDocs with Material theme and GitHub Pages deployment
+- **`docs=n`** - Minimal documentation setup
+
+### Typed Configuration  
+- **`typed_config=y`** - Pydantic-based settings with validation and type safety
+- **`typed_config=n`** - Traditional configuration system
+
+### Security & Compliance
+- **`sbom=y`** - Software Bill of Materials generation with CycloneDX/SPDX
+- **`sbom=n`** - Standard security workflows only
+
+### Versioning Strategy
+- **`setuptools-scm`** - Automatic versioning from Git tags
+- **`hatch`** - Hatch-based versioning (when using Hatch package manager)
+- **`manual`** - Manual version management
+
+## Common Usage Examples
+
+### Minimal Library Project
+
+For a simple Python library with basic features:
+```bash
+cookiecutter https://github.com/retr0crypticghost/python-template.git --no-input \
+  project_name="My Library" \
+  project_type="library" \
+  package_manager="pip" \
+  docs="n" \
+  typed_config="n" \
+  sbom="n" \
+  versioning="manual"
+```
+
+### Full-Featured CLI Application  
+
+For a professional command-line tool with all features:
+```bash
+cookiecutter https://github.com/retr0crypticghost/python-template.git --no-input \
+  project_name="My CLI Tool" \
+  project_type="cli-application" \
+  package_manager="uv" \
+  docs="y" \
+  typed_config="y" \
+  sbom="y" \
+  versioning="setuptools-scm"
+```
+
+### Enterprise Library
+
+For a library with enterprise-grade features:
+```bash
+cookiecutter https://github.com/retr0crypticghost/python-template.git --no-input \
+  project_name="Enterprise Library" \
+  project_type="library" \
+  package_manager="hatch" \
+  docs="y" \
+  typed_config="y" \
+  sbom="y" \
+  versioning="hatch"
+```
+
+### Quick Development Project
+
+For rapid prototyping with modern tooling:
+```bash
+cookiecutter https://github.com/retr0crypticghost/python-template.git --no-input \
+  project_name="Quick Project" \
+  project_type="library" \
+  package_manager="uv" \
+  docs="n" \
+  typed_config="y" \
+  sbom="n" \
+  versioning="manual"
+```
 
 ## Generated Project Structure
 
@@ -278,25 +393,35 @@ Additional templates planned based on actual project needs.
 ### **vs. Basic Templates**
 
 **Most templates give you**: Basic project structure, minimal configuration, simple testing setup
-**This template provides**: Security practices, professional tooling, comprehensive testing
+**This template provides**: Enterprise-grade security, flexible tooling, comprehensive automation
 
 | Feature | Basic Templates | Python Professional Template |
-|---------|----------------|----------------------------|
-| **Logging** | `logging.getLogger()` | Security filtering, thread safety, structured output |
-| **Configuration** | Basic config.py | Hierarchical system with validation |
-| **CLI Tools** | argparse basics | Rich interface with completion and man pages |
-| **Testing** | pytest setup | 90%+ coverage requirement with security testing |
-| **Security** | None | Sensitive data protection and audit capabilities |
-| **CI/CD** | Basic workflows | Multi-Python testing with quality gates |
+|---------|----------------|------------------------------|
+| **Logging** | `logging.getLogger()` | JSON logging with request IDs, security filtering, context management |
+| **Configuration** | Basic config.py | Typed Pydantic settings OR traditional hierarchical system |
+| **Package Management** | pip only | pip, uv, or Hatch with optimized configurations |
+| **CLI Tools** | argparse basics | Rich interface with completion, man pages, and context help |
+| **Testing** | pytest setup | Multi-OS, multi-Python with 90%+ coverage and security testing |
+| **Security** | None | SBOM generation, dependency auditing, sensitive data protection |
+| **CI/CD** | Basic workflows | Multi-environment with quality gates, security scanning, SBOM |
+| **Documentation** | README only | Optional MkDocs with auto-deployment and API docs |
+
+### **Enterprise Features**
+
+- **Supply Chain Security**: SBOM generation, dependency auditing, vulnerability scanning
+- **Observability**: Request/operation ID tracking, structured JSON logging, context propagation
+- **Flexibility**: Choose your package manager (pip/uv/hatch), configuration style (typed/traditional)
+- **Compliance Ready**: Security workflows, audit logging, dependency management
+- **Developer Experience**: Type hints, IDE support, comprehensive documentation
 
 ### **Time Savings**
 
-- **Skip repetitive setup**: No more copying logging/config code between projects
-- **Avoid security mistakes**: Built-in patterns for handling sensitive data
-- **Professional polish**: CLI tools that work like system utilities
-- **Quality foundations**: Testing and CI/CD setup that actually enforces standards
+- **Zero configuration**: Everything works out of the box with sensible defaults
+- **No vendor lock-in**: Choose your tools (package manager, versioning, documentation)
+- **Production ready**: Security patterns, logging, and monitoring built-in
+- **Maintenance free**: Automated dependency updates, security scanning, and quality checks
 
-> **Bottom Line**: Get projects that look and work professionally without the manual setup time.
+> **Bottom Line**: Get enterprise-grade Python projects without the complexity—choose only the features you need.
 
 ## Project Types
 
diff --git a/cookiecutter.json b/cookiecutter.json
index 75c13db..b712d6b 100644
--- a/cookiecutter.json
+++ b/cookiecutter.json
@@ -7,7 +7,12 @@
   "github_username": "your-username",
   "project_description": "A brief description of your project",
   "python_version": "3.11",
-  "project_type": ["library", "cli-application", "web-api", "data-science"],
+  "project_type": ["library", "cli-application"],
+  "package_manager": ["pip", "uv", "hatch"],
+  "docs": ["y", "n"],
+  "typed_config": ["n", "y"],
+  "sbom": ["n", "y"],
+  "versioning": ["setuptools-scm", "manual", "hatch"],
   "include_docker": "n",
   "include_github_actions": "y",
   "include_pre_commit": "y",
diff --git a/hooks/post_gen_project.py b/hooks/post_gen_project.py
index 385528b..774f585 100644
--- a/hooks/post_gen_project.py
+++ b/hooks/post_gen_project.py
@@ -29,9 +29,8 @@ def remove_directory(dirpath):
         print(f"Removed {dirpath}")
 
 
-def main():
-    """Main post-generation logic."""
-
+def cleanup_project_type():
+    """Handle project type specific cleanup."""
     project_type = "{{ cookiecutter.project_type }}"
 
     if project_type == "library":
@@ -42,6 +41,9 @@ def main():
         # Remove CLI module for library projects
         cli_module = "src/{{ cookiecutter.package_name }}/cli.py"
         remove_file(cli_module)
+        
+        # Remove CLI tests
+        remove_file("tests/test_cli.py")
 
         print("✅ Library project configured - removed CLI components")
 
@@ -52,6 +54,73 @@ def main():
     else:
         print(f"⚠️  Unknown project type: {project_type}")
 
+
+def cleanup_docs():
+    """Handle documentation cleanup based on docs option."""
+    docs_enabled = "{{ cookiecutter.docs }}" == "y"
+    
+    if not docs_enabled:
+        remove_file("mkdocs.yml")
+        remove_directory("docs")
+        
+        # Remove docs workflow
+        remove_file(".github/workflows/docs.yml")
+        
+        print("✅ Documentation disabled - removed MkDocs files")
+    else:
+        print("✅ Documentation enabled - kept MkDocs files")
+
+
+def cleanup_typed_config():
+    """Handle typed config cleanup."""
+    typed_config_enabled = "{{ cookiecutter.typed_config }}" == "y"
+    
+    if not typed_config_enabled:
+        # Remove Pydantic settings file if it exists
+        remove_file("src/{{ cookiecutter.package_name }}/settings.py")
+        print("✅ Typed config disabled - using standard config")
+    else:
+        print("✅ Typed config enabled - Pydantic settings available")
+
+
+def cleanup_sbom():
+    """Handle SBOM workflow cleanup."""
+    sbom_enabled = "{{ cookiecutter.sbom }}" == "y"
+    
+    if not sbom_enabled:
+        remove_file(".github/workflows/sbom.yml")
+        print("✅ SBOM generation disabled - removed workflow")
+    else:
+        print("✅ SBOM generation enabled - workflow available")
+
+
+def cleanup_versioning():
+    """Handle versioning cleanup based on versioning option."""
+    versioning = "{{ cookiecutter.versioning }}"
+    
+    if versioning == "manual":
+        # Remove versioning files for manual versioning
+        remove_file("_version.py")  # setuptools-scm version file
+        print("✅ Manual versioning configured")
+    elif versioning == "setuptools-scm":
+        print("✅ setuptools-scm versioning configured")
+    elif versioning == "hatch":
+        print("✅ Hatch versioning configured")
+
+
+def main():
+    """Main post-generation logic."""
+    print("🔧 Configuring generated project...")
+
+    # Handle different project types
+    cleanup_project_type()
+    
+    # Handle optional features
+    cleanup_docs()
+    cleanup_typed_config()
+    cleanup_sbom()
+    cleanup_versioning()
+
     print("✅ Project generation completed successfully!")
 
 
diff --git a/hooks/pre_gen_project.py b/hooks/pre_gen_project.py
new file mode 100644
index 0000000..3844926
--- /dev/null
+++ b/hooks/pre_gen_project.py
@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""
+Pre-generation hook for python-template cookiecutter.
+
+This script runs before the project is generated and validates
+the user inputs, ensuring they meet requirements.
+"""
+
+import re
+import sys
+from pathlib import Path
+
+
+def validate_package_name(package_name: str) -> bool:
+    """
+    Validate that package_name is a valid Python identifier.
+    
+    Args:
+        package_name: The package name to validate
+        
+    Returns:
+        bool: True if valid, False otherwise
+    """
+    # Check if it's a valid Python identifier
+    if not package_name.isidentifier():
+        return False
+    
+    # Check for Python keywords
+    import keyword
+    if keyword.iskeyword(package_name):
+        return False
+        
+    # Check for reserved names
+    reserved_names = {
+        'test', 'tests', 'lib', 'src', 'docs', 'examples', 'example',
+        'setup', 'build', 'dist', 'egg-info', '__pycache__'
+    }
+    if package_name.lower() in reserved_names:
+        return False
+    
+    return True
+
+
+def normalize_project_slug(project_slug: str) -> str:
+    """
+    Normalize project slug to follow best practices.
+    
+    Args:
+        project_slug: The project slug to normalize
+        
+    Returns:
+        str: Normalized project slug
+    """
+    # Convert to lowercase
+    slug = project_slug.lower()
+    
+    # Replace spaces and underscores with hyphens
+    slug = re.sub(r'[\s_]+', '-', slug)
+    
+    # Remove invalid characters
+    slug = re.sub(r'[^a-z0-9\-]', '', slug)
+    
+    # Remove leading/trailing hyphens and collapse multiple hyphens
+    slug = re.sub(r'-+', '-', slug).strip('-')
+    
+    return slug
+
+
+def validate_inputs():
+    """Validate all cookiecutter inputs."""
+    errors = []
+    
+    # Get cookiecutter variables
+    package_name = "{{ cookiecutter.package_name }}"
+    project_slug = "{{ cookiecutter.project_slug }}"
+    project_type = "{{ cookiecutter.project_type }}"
+    package_manager = "{{ cookiecutter.package_manager }}"
+    python_version = "{{ cookiecutter.python_version }}"
+    
+    # Validate package name
+    if not validate_package_name(package_name):
+        errors.append(f"❌ Invalid package_name '{package_name}': Must be a valid Python identifier")
+        errors.append("   - Cannot contain spaces, hyphens, or special characters")
+        errors.append("   - Cannot be a Python keyword")
+        errors.append("   - Cannot be a reserved name (test, tests, lib, src, etc.)")
+        
+    # Validate project type
+    valid_project_types = ["library", "cli-application"]
+    if project_type not in valid_project_types:
+        errors.append(f"❌ Invalid project_type '{project_type}': Must be one of {valid_project_types}")
+    
+    # Validate package manager
+    valid_package_managers = ["pip", "uv", "hatch"]
+    if package_manager not in valid_package_managers:
+        errors.append(f"❌ Invalid package_manager '{package_manager}': Must be one of {valid_package_managers}")
+    
+    # Validate Python version format
+    try:
+        version_parts = python_version.split('.')
+        if len(version_parts) != 2:
+            raise ValueError("Invalid format")
+        major, minor = int(version_parts[0]), int(version_parts[1])
+        if major != 3 or minor < 11:
+            errors.append(f"❌ Invalid python_version '{python_version}': Must be 3.11 or higher")
+    except ValueError:
+        errors.append(f"❌ Invalid python_version '{python_version}': Must be in format 'X.Y' (e.g., '3.11')")
+    
+    # Check for potential slug issues (warn but don't fail)
+    normalized_slug = normalize_project_slug(project_slug)
+    if project_slug != normalized_slug:
+        print(f"⚠️  Project slug '{project_slug}' would be normalized to '{normalized_slug}'")
+        print("   Consider using the normalized version for better compatibility")
+    
+    if errors:
+        print("🛑 Cookiecutter validation failed:")
+        print()
+        for error in errors:
+            print(error)
+        print()
+        print("💡 Tips:")
+        print("   - Use underscores for package_name: my_package")  
+        print("   - Use hyphens for project_slug: my-project")
+        print("   - Choose from supported project types: library, cli-application")
+        print("   - Choose from supported package managers: pip, uv, hatch")
+        sys.exit(1)
+    
+    print("✅ Input validation passed!")
+
+
+def main():
+    """Main pre-generation logic."""
+    print("🔍 Validating cookiecutter inputs...")
+    validate_inputs()
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/test_template.sh b/test_template.sh
index d160f5f..48dade5 100755
--- a/test_template.sh
+++ b/test_template.sh
@@ -1,48 +1,141 @@
 #!/bin/bash
 set -e
 
-echo "🧪 Testing Python Template Generation..."
+echo "🧪 Testing Python Template Generation with Enhanced Options..."
 
-# Clean up any existing test projects
-rm -rf test-library test-cli-app
+# Test all combinations of key features
+test_combinations=(
+    # Format: "name:project_type:package_manager:docs:typed_config:sbom:versioning"
+    "library-pip-basic:library:pip:n:n:n:manual"
+    "library-pip-full:library:pip:y:y:y:setuptools-scm"
+    "cli-uv-basic:cli-application:uv:n:n:n:manual"
+    "cli-hatch-full:cli-application:hatch:y:y:y:hatch"
+    "library-uv-typed:library:uv:y:y:n:manual"
+    "cli-pip-sbom:cli-application:pip:n:n:y:setuptools-scm"
+)
 
-echo "📚 Testing Library Project Generation..."
-cookiecutter . --no-input \
-    project_name="Test Library" \
-    project_slug="test-library" \
-    project_type="library"
-
-echo "✅ Library project generated successfully"
-
-echo "⚡ Testing CLI Application Generation..."
-cookiecutter . --no-input \
-    project_name="Test CLI App" \
-    project_slug="test-cli-app" \
-    project_type="cli-application"
+echo "🔧 Testing ${#test_combinations[@]} different combinations..."
 
-echo "✅ CLI application generated successfully"
+for combo in "${test_combinations[@]}"; do
+    IFS=':' read -r name project_type package_manager docs typed_config sbom versioning <<< "$combo"
+    
+    echo "📦 Testing: $name"
+    echo "  - Project Type: $project_type"
+    echo "  - Package Manager: $package_manager"  
+    echo "  - Docs: $docs"
+    echo "  - Typed Config: $typed_config"
+    echo "  - SBOM: $sbom"
+    echo "  - Versioning: $versioning"
+    
+    # Clean up any existing test project
+    rm -rf "test-$name"
+    
+    # Generate project with specific options
+    cookiecutter . --no-input \
+        project_name="Test $name" \
+        project_slug="test-$name" \
+        project_type="$project_type" \
+        package_manager="$package_manager" \
+        docs="$docs" \
+        typed_config="$typed_config" \
+        sbom="$sbom" \
+        versioning="$versioning" \
+        include_docker="n" \
+        include_github_actions="y" \
+        include_pre_commit="y" \
+        license="MIT"
+    
+    echo "✅ Generated: test-$name"
+done
 
 echo "🔍 Validating Generated Projects..."
 
-# Check that key files exist
-echo "  🔍 Checking library project structure..."
-test -f test-library/pyproject.toml || (echo "❌ Missing pyproject.toml in library" && exit 1)
-test -f test-library/src/test_library/__init__.py || (echo "❌ Missing __init__.py in library" && exit 1)
-test -f test-library/tests/test_core.py || (echo "❌ Missing test file in library" && exit 1)
+# Validate each generated project
+for combo in "${test_combinations[@]}"; do
+    IFS=':' read -r name project_type package_manager docs typed_config sbom versioning <<< "$combo"
+    project_dir="test-$name"
+    # The package name is derived from the full project slug (test-$name)
+    full_project_slug="test-$name"
+    package_name=$(echo "$full_project_slug" | tr '-' '_')
+    
+    echo "  🔍 Validating: $project_dir (package: $package_name)"
+    
+    # Check basic structure
+    test -f "$project_dir/pyproject.toml" || (echo "❌ Missing pyproject.toml in $project_dir" && exit 1)
+    test -f "$project_dir/src/$package_name/__init__.py" || (echo "❌ Missing __init__.py in $project_dir" && exit 1)
+    test -f "$project_dir/src/$package_name/config.py" || (echo "❌ Missing config.py in $project_dir" && exit 1)
+    test -f "$project_dir/src/$package_name/logger.py" || (echo "❌ Missing logger.py in $project_dir" && exit 1)
+    test -d "$project_dir/tests" || (echo "❌ Missing tests directory in $project_dir" && exit 1)
+    
+    # Check project type specific files
+    if [ "$project_type" = "cli-application" ]; then
+        test -f "$project_dir/src/$package_name/cli.py" || (echo "❌ CLI project missing cli.py" && exit 1)
+        test -f "$project_dir/run_test-$name.py" || (echo "❌ CLI project missing run script" && exit 1)
+        test -f "$project_dir/tests/test_cli.py" || (echo "❌ CLI project missing CLI tests" && exit 1)
+    else
+        test ! -f "$project_dir/src/$package_name/cli.py" || (echo "❌ Library should not have cli.py" && exit 1)
+        test ! -f "$project_dir/run_test-$name.py" || (echo "❌ Library should not have run script" && exit 1)
+        test ! -f "$project_dir/tests/test_cli.py" || (echo "❌ Library should not have CLI tests" && exit 1)
+    fi
+    
+    # Check docs option
+    if [ "$docs" = "y" ]; then
+        test -f "$project_dir/mkdocs.yml" || (echo "❌ Docs enabled but mkdocs.yml missing" && exit 1)
+        test -d "$project_dir/docs" || (echo "❌ Docs enabled but docs directory missing" && exit 1)
+        test -f "$project_dir/.github/workflows/docs.yml" || (echo "❌ Docs enabled but docs workflow missing" && exit 1)
+    else
+        test ! -f "$project_dir/mkdocs.yml" || (echo "❌ Docs disabled but mkdocs.yml exists" && exit 1)
+        test ! -d "$project_dir/docs" || (echo "❌ Docs disabled but docs directory exists" && exit 1)
+        test ! -f "$project_dir/.github/workflows/docs.yml" || (echo "❌ Docs disabled but docs workflow exists" && exit 1)
+    fi
+    
+    # Check typed_config option
+    if [ "$typed_config" = "y" ]; then
+        test -f "$project_dir/src/$package_name/settings.py" || (echo "❌ Typed config enabled but settings.py missing" && exit 1)
+        test -f "$project_dir/tests/test_settings.py" || (echo "❌ Typed config enabled but settings tests missing" && exit 1)
+    else
+        test ! -f "$project_dir/src/$package_name/settings.py" || (echo "❌ Typed config disabled but settings.py exists" && exit 1)
+    fi
+    
+    # Check SBOM option
+    if [ "$sbom" = "y" ]; then
+        test -f "$project_dir/.github/workflows/sbom.yml" || (echo "❌ SBOM enabled but workflow missing" && exit 1)
+    else
+        test ! -f "$project_dir/.github/workflows/sbom.yml" || (echo "❌ SBOM disabled but workflow exists" && exit 1)
+    fi
+    
+    # Check versioning in pyproject.toml
+    if [ "$versioning" = "setuptools-scm" ]; then
+        grep -q "setuptools_scm" "$project_dir/pyproject.toml" || (echo "❌ setuptools-scm versioning but no setuptools_scm config" && exit 1)
+    elif [ "$versioning" = "hatch" ] && [ "$package_manager" = "hatch" ]; then
+        grep -q "hatch.version" "$project_dir/pyproject.toml" || (echo "❌ Hatch versioning but no hatch.version config" && exit 1)
+    fi
+    
+    echo "    ✅ Structure validation passed"
+done
 
-echo "  🔍 Checking CLI project structure..."
-test -f test-cli-app/pyproject.toml || (echo "❌ Missing pyproject.toml in CLI app" && exit 1)
-test -f test-cli-app/src/test_cli_app/__init__.py || (echo "❌ Missing __init__.py in CLI app" && exit 1)
-test -f test-cli-app/src/test_cli_app/cli.py || (echo "❌ Missing cli.py in CLI app" && exit 1)
-test -f test-cli-app/tests/test_core.py || (echo "❌ Missing test file in CLI app" && exit 1)
+echo "🧹 Cleaning up test projects..."
+for combo in "${test_combinations[@]}"; do
+    IFS=':' read -r name project_type package_manager docs typed_config sbom versioning <<< "$combo"
+    rm -rf "test-$name"
+done
 
-# Check that library doesn't have CLI files
-test ! -f test-library/src/test_library/cli.py || (echo "❌ Library should not have cli.py" && exit 1)
+echo "🎉 All validation tests passed! Enhanced template is working correctly."
 
-# Check that CLI has extra files
-test -f test-cli-app/run_test-cli-app.py || (echo "❌ CLI app missing run script" && exit 1)
+# Test basic functionality with a simple generation
+echo "🚀 Testing basic functionality with library generation..."
+rm -rf test-functionality
+cookiecutter . --no-input \
+    project_name="Test Functionality" \
+    project_slug="test-functionality" \
+    project_type="library" \
+    package_manager="pip" \
+    docs="n" \
+    typed_config="n" \
+    sbom="n" \
+    versioning="manual"
 
-echo "🧹 Cleaning up test projects..."
-rm -rf test-library test-cli-app
+echo "✅ Basic functionality test passed!"
+rm -rf test-functionality
 
-echo "🎉 All validation tests passed! Template is working correctly."
+echo "🎉 All enhanced template tests completed successfully!"
diff --git a/{{cookiecutter.project_slug}}/.github/release-drafter.yml b/{{cookiecutter.project_slug}}/.github/release-drafter.yml
new file mode 100644
index 0000000..4f49421
--- /dev/null
+++ b/{{cookiecutter.project_slug}}/.github/release-drafter.yml
@@ -0,0 +1,64 @@
+name-template: 'v$RESOLVED_VERSION'
+tag-template: 'v$RESOLVED_VERSION'
+
+categories:
+  - title: '🚀 Features'
+    labels:
+      - 'feature'
+      - 'enhancement'
+  - title: '🐛 Bug Fixes'
+    labels:
+      - 'fix'
+      - 'bugfix'
+      - 'bug'
+  - title: '🧰 Maintenance'
+    labels:
+      - 'chore'
+      - 'maintenance'
+  - title: '📚 Documentation'
+    labels:
+      - 'documentation'
+      - 'docs'
+  - title: '🔒 Security'
+    labels:
+      - 'security'
+  - title: '⚡ Performance'
+    labels:
+      - 'performance'
+      - 'perf'
+
+change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
+
+change-title-escapes: '\<*_&'
+
+version-resolver:
+  major:
+    labels:
+      - 'major'
+      - 'breaking'
+  minor:
+    labels:
+      - 'minor'
+      - 'feature'
+      - 'enhancement'
+  patch:
+    labels:
+      - 'patch'
+      - 'fix'
+      - 'bugfix'
+      - 'bug'
+      - 'chore'
+      - 'maintenance'
+      - 'security'
+  default: patch
+
+template: |
+  ## Changes
+
+  $CHANGES
+
+  ## Contributors
+
+  Thanks to all contributors who made this release possible! 🎉
+
+  $CONTRIBUTORS
\ No newline at end of file
diff --git a/{{cookiecutter.project_slug}}/.github/workflows/ci.yml b/{{cookiecutter.project_slug}}/.github/workflows/ci.yml
index bccc73c..9ea4e55 100644
--- a/{{cookiecutter.project_slug}}/.github/workflows/ci.yml
+++ b/{{cookiecutter.project_slug}}/.github/workflows/ci.yml
@@ -11,12 +11,13 @@ permissions:
 
 jobs:
   test:
-    name: Test Python ${% raw %}{{ matrix.python-version }}{% endraw %}
-    runs-on: ubuntu-latest
+    name: Test Python ${% raw %}{{ matrix.python-version }}{% endraw %} on ${% raw %}{{ matrix.os }}{% endraw %}
+    runs-on: ${% raw %}{{ matrix.os }}{% endraw %}
     strategy:
       fail-fast: false
       matrix:
         python-version: ["3.11", "3.12", "3.13"]
+        os: [ubuntu-latest, windows-latest]
 
     steps:
       - name: Checkout code
@@ -32,21 +33,65 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
+          {%- if cookiecutter.package_manager == "uv" %}
+          pip install uv
+          uv pip install -e ".[dev]"
+          {%- elif cookiecutter.package_manager == "hatch" %}
+          pip install hatch
+          hatch env create
+          {%- else %}
           pip install -e ".[dev]"
+          {%- endif %}
 
       - name: Run pre-commit hooks
         uses: pre-commit/action@2c7b3805fd2a0fd8c1884dcaebf91fc102a13ecd  # v3.0.1
 
       - name: Lint with Ruff
         run: |
+          {%- if cookiecutter.package_manager == "hatch" %}
+          hatch run ruff check .
+          hatch run ruff format --check .
+          {%- else %}
           ruff check .
           ruff format --check .
+          {%- endif %}
 
       - name: Type check with mypy
-        run: mypy src/
+        run: |
+          {%- if cookiecutter.package_manager == "hatch" %}
+          hatch run mypy src/
+          {%- else %}
+          mypy src/
+          {%- endif %}
+
+      - name: Security audit with pip-audit
+        run: |
+          {%- if cookiecutter.package_manager == "uv" %}
+          pip install pip-audit
+          uv pip list --format=json | pip-audit --desc --format=json --input-format=json
+          {%- elif cookiecutter.package_manager == "hatch" %}
+          pip install pip-audit
+          hatch run pip list --format=json | pip-audit --desc --format=json --input-format=json
+          {%- else %}
+          pip install pip-audit
+          pip-audit --desc --format=json
+          {%- endif %}
 
       - name: Test with pytest
-        run: pytest -q --cov --cov-report=xml -W error
+        run: |
+          {%- if cookiecutter.package_manager == "hatch" %}
+          hatch run pytest -q --cov --cov-report=xml -W error
+          {%- else %}
+          pytest -q --cov --cov-report=xml -W error
+          {%- endif %}
+
+      - name: Upload coverage to Codecov
+        if: matrix.os == 'ubuntu-latest' && matrix.python-version == '{{ cookiecutter.python_version }}'
+        uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673  # v4.5.0
+        with:
+          files: ./coverage.xml
+          fail_ci_if_error: false
+          verbose: true
 
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673  # v4.5.0
diff --git a/{{cookiecutter.project_slug}}/.github/workflows/docs.yml b/{{cookiecutter.project_slug}}/.github/workflows/docs.yml
index 59917ca..dc24a1d 100644
--- a/{{cookiecutter.project_slug}}/.github/workflows/docs.yml
+++ b/{{cookiecutter.project_slug}}/.github/workflows/docs.yml
@@ -1,3 +1,4 @@
+{%- if cookiecutter.docs == 'y' %}
 name: Documentation
 
 on:
@@ -21,15 +22,28 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3  # v5.1.0
         with:
-          python-version: '3.12'
+          python-version: '{{ cookiecutter.python_version }}'
 
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
+          {%- if cookiecutter.package_manager == "uv" %}
+          pip install uv
+          uv pip install -e ".[dev]"
+          {%- elif cookiecutter.package_manager == "hatch" %}
+          pip install hatch
+          hatch env create
+          {%- else %}
           pip install -e ".[dev]"
+          {%- endif %}
 
       - name: Build documentation
-        run: mkdocs build --clean --strict
+        run: |
+          {%- if cookiecutter.package_manager == "hatch" %}
+          hatch run mkdocs build --clean --strict
+          {%- else %}
+          mkdocs build --clean --strict
+          {%- endif %}
 
       - name: Upload documentation artifact
         uses: actions/upload-artifact@834a144ee995460fba8ed112a2fc961b36a5ec5a  # v4.3.6
@@ -60,3 +74,4 @@ jobs:
           github_token: ${% raw %}{{ secrets.GITHUB_TOKEN }}{% endraw %}
           publish_dir: ./site
           cname: ${% raw %}{{ github.event.repository.homepage }}{% endraw %}  # Use custom domain if set
+{%- endif %}
diff --git a/{{cookiecutter.project_slug}}/.github/workflows/release-drafter.yml b/{{cookiecutter.project_slug}}/.github/workflows/release-drafter.yml
new file mode 100644
index 0000000..2ebdf6e
--- /dev/null
+++ b/{{cookiecutter.project_slug}}/.github/workflows/release-drafter.yml
@@ -0,0 +1,24 @@
+name: Release Drafter
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    types: [opened, reopened, synchronize]
+
+permissions:
+  contents: read
+
+jobs:
+  update_release_draft:
+    name: Update Release Draft
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: read
+    
+    steps:
+      - name: Update release draft
+        uses: release-drafter/release-drafter@3f0f87098bd6b5c5b9a36d49c41d998ea58f9348  # v6.0.0
+        env:
+          GITHUB_TOKEN: ${% raw %}{{ secrets.GITHUB_TOKEN }}{% endraw %}
\ No newline at end of file
diff --git a/{{cookiecutter.project_slug}}/.github/workflows/sbom.yml b/{{cookiecutter.project_slug}}/.github/workflows/sbom.yml
new file mode 100644
index 0000000..f76ac08
--- /dev/null
+++ b/{{cookiecutter.project_slug}}/.github/workflows/sbom.yml
@@ -0,0 +1,92 @@
+name: SBOM Generation
+
+on:
+  push:
+    branches: [main]
+    tags: ['v*']
+  pull_request:
+    branches: [main]
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  id-token: write # Required for OIDC attestation
+  attestations: write # Required for attestation creation
+
+jobs:
+  sbom:
+    name: Generate SBOM
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332  # v4.1.7
+
+      - name: Set up Python
+        uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3  # v5.1.0
+        with:
+          python-version: '{{ cookiecutter.python_version }}'
+          cache: pip
+          cache-dependency-path: pyproject.toml
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Install Syft
+        uses: anchore/sbom-action/download-syft@61119d458adab75f756bc0b9e4bde25725f86a7a  # v0.17.2
+
+      - name: Generate SBOM with Syft
+        run: |
+          syft packages dir:. -o cyclonedx-json=sbom.json -o spdx-json=sbom.spdx.json
+          echo "Generated SBOM files:"
+          ls -la sbom.*
+
+      - name: Validate SBOM
+        run: |
+          # Basic validation - check if files exist and are not empty
+          if [ ! -s sbom.json ]; then
+            echo "❌ CycloneDX SBOM is empty or missing"
+            exit 1
+          fi
+          
+          if [ ! -s sbom.spdx.json ]; then
+            echo "❌ SPDX SBOM is empty or missing"
+            exit 1
+          fi
+          
+          echo "✅ SBOM files validated successfully"
+          
+          # Show some basic stats
+          echo "CycloneDX components:"
+          jq '.components | length' sbom.json
+          echo "SPDX packages:"
+          jq '.packages | length' sbom.spdx.json
+
+      - name: Upload SBOM artifacts
+        uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874  # v4.4.0
+        with:
+          name: sbom-${% raw %}{{ github.sha }}{% endraw %}
+          path: |
+            sbom.json
+            sbom.spdx.json
+          retention-days: 90
+
+      - name: Attest SBOM (on release)
+        if: github.event_name == 'release'
+        uses: actions/attest-sbom@1c608d11d69870c2092266b3f9a6ac1a7b9058ad  # v1.4.0
+        with:
+          subject-path: 'sbom.json'
+          sbom-path: 'sbom.json'
+
+      - name: Upload SBOM to release (on release)
+        if: github.event_name == 'release'
+        uses: softprops/action-gh-release@c062e08bd532815e2082a85e87e3ef29c3e6d191  # v2.0.8
+        with:
+          files: |
+            sbom.json
+            sbom.spdx.json
+        env:
+          GITHUB_TOKEN: ${% raw %}{{ secrets.GITHUB_TOKEN }}{% endraw %}
\ No newline at end of file
diff --git a/{{cookiecutter.project_slug}}/docs/cli-usage.md b/{{cookiecutter.project_slug}}/docs/cli-usage.md
new file mode 100644
index 0000000..11d3fdd
--- /dev/null
+++ b/{{cookiecutter.project_slug}}/docs/cli-usage.md
@@ -0,0 +1,326 @@
+{%- if cookiecutter.docs == 'y' and cookiecutter.project_type == "cli-application" %}
+# CLI Usage
+
+{{ cookiecutter.project_name }} provides a rich command-line interface built with Click and Rich for an excellent user experience.
+
+## Installation
+
+After installing the package, the CLI commands become available:
+
+```bash
+# Install the package
+pip install {{ cookiecutter.project_slug }}
+
+# The main command is now available
+{{ cookiecutter.package_name }} --help
+```
+
+## Available Commands
+
+### Main Command
+
+```bash
+{{ cookiecutter.package_name }} --help
+```
+
+This shows all available commands and global options.
+
+### Status Command
+
+Check the application status and configuration:
+
+```bash
+{{ cookiecutter.package_name }} status
+```
+
+This command displays:
+- Application name and version
+- Current configuration summary
+- System information
+- Feature flags status
+
+### Hello Command
+
+Example interactive command with options:
+
+```bash
+# Simple greeting
+{{ cookiecutter.package_name }} hello "World"
+
+# Repeat the greeting
+{{ cookiecutter.package_name }} hello "World" --count 3
+
+# Use different greeting style
+{{ cookiecutter.package_name }} hello "World" --style fancy
+```
+
+### Info Command
+
+Display detailed information about the application:
+
+```bash
+{{ cookiecutter.package_name }} info
+```
+
+## Global Options
+
+All commands support these global options:
+
+### Configuration
+
+```bash
+# Use a specific configuration file
+{{ cookiecutter.package_name }} --config config/production.yaml status
+
+# Set log level
+{{ cookiecutter.package_name }} --log-level DEBUG status
+
+# Enable verbose output
+{{ cookiecutter.package_name }} --verbose status
+
+# Quiet mode (minimal output)
+{{ cookiecutter.package_name }} --quiet status
+```
+
+### Output Formatting
+
+```bash
+# JSON output (for scripting)
+{{ cookiecutter.package_name }} --output json status
+
+# Plain text output (no colors/formatting)
+{{ cookiecutter.package_name }} --output plain status
+
+# Default rich output (colors and formatting)
+{{ cookiecutter.package_name }} --output rich status
+```
+
+## Environment Variables
+
+The CLI respects environment variables for configuration:
+
+```bash
+# Set global configuration
+export {{ cookiecutter.package_name|upper }}_LOG_LEVEL=DEBUG
+export {{ cookiecutter.package_name|upper }}_CONFIG_FILE=config/staging.yaml
+
+# Command-specific settings
+export {{ cookiecutter.package_name|upper }}_API_TIMEOUT=60
+export {{ cookiecutter.package_name|upper }}_DATABASE_URL=postgresql://localhost/mydb
+
+# Run command with environment config
+{{ cookiecutter.package_name }} status
+```
+
+## Examples
+
+### Basic Usage
+
+```bash
+# Check application status
+{{ cookiecutter.package_name }} status
+
+# Get detailed information
+{{ cookiecutter.package_name }} info
+
+# Simple hello world
+{{ cookiecutter.package_name }} hello "{{ cookiecutter.author_name }}"
+```
+
+### Configuration Management
+
+```bash
+# Use development configuration
+{{ cookiecutter.package_name }} --config config/dev.yaml status
+
+# Use production settings with debug logging
+{{ cookiecutter.package_name }} --config config/prod.yaml --log-level DEBUG status
+
+# Override configuration with environment variables
+{{ cookiecutter.package_name|upper }}_API_TIMEOUT=120 {{ cookiecutter.package_name }} status
+```
+
+### Output Formatting
+
+```bash
+# Get status as JSON (useful for scripts)
+{{ cookiecutter.package_name }} --output json status
+
+# Get quiet output (just the essentials)
+{{ cookiecutter.package_name }} --quiet status
+
+# Verbose debug information
+{{ cookiecutter.package_name }} --verbose --log-level DEBUG status
+```
+
+### Batch Operations
+
+```bash
+# Process multiple items
+{{ cookiecutter.package_name }} hello "Alice" "Bob" "Charlie" --count 2
+
+# Chain commands with different configs
+{{ cookiecutter.package_name }} --config dev.yaml status && \
+{{ cookiecutter.package_name }} --config prod.yaml status
+```
+
+## Shell Integration
+
+### Command Completion
+
+Generate shell completion scripts:
+
+```bash
+# For bash
+{{ cookiecutter.package_name }} completion bash > ~/.bash_completion.d/{{ cookiecutter.package_name }}
+
+# For zsh  
+{{ cookiecutter.package_name }} completion zsh > ~/.zsh/completions/_{{ cookiecutter.package_name }}
+
+# For fish
+{{ cookiecutter.package_name }} completion fish > ~/.config/fish/completions/{{ cookiecutter.package_name }}.fish
+
+# For PowerShell
+{{ cookiecutter.package_name }} completion powershell > {{ cookiecutter.package_name }}.ps1
+```
+
+### Man Page
+
+Install the manual page:
+
+```bash
+# Generate and install man page
+{{ cookiecutter.package_name }}-man
+
+# View the man page
+man {{ cookiecutter.package_name }}
+```
+
+## Exit Codes
+
+The CLI uses standard exit codes:
+
+- `0` - Success
+- `1` - General error  
+- `2` - Command line usage error
+- `3` - Configuration error
+- `4` - Network/API error
+- `5` - File system error
+
+Example usage in scripts:
+
+```bash
+#!/bin/bash
+
+if {{ cookiecutter.package_name }} status --quiet; then
+    echo "Application is healthy"
+else
+    echo "Application check failed with exit code $?"
+    exit 1
+fi
+```
+
+## Error Handling
+
+The CLI provides helpful error messages:
+
+```bash
+# Invalid command
+{{ cookiecutter.package_name }} invalid-command
+# Error: No such command 'invalid-command'.
+
+# Missing required argument
+{{ cookiecutter.package_name }} hello
+# Error: Missing argument 'name'.
+
+# Configuration error
+{{ cookiecutter.package_name }} --config missing.yaml status  
+# Error: Configuration file 'missing.yaml' not found.
+```
+
+## Debugging
+
+### Verbose Mode
+
+```bash
+# Enable verbose output
+{{ cookiecutter.package_name }} --verbose status
+
+# Debug logging
+{{ cookiecutter.package_name }} --log-level DEBUG status
+
+# Both verbose and debug
+{{ cookiecutter.package_name }} --verbose --log-level DEBUG status
+```
+
+### Configuration Debugging
+
+```bash
+# Show effective configuration
+{{ cookiecutter.package_name }} --verbose status
+
+# Test configuration loading
+{{ cookiecutter.package_name }} --config test.yaml --verbose status
+
+# Show environment variable usage
+{{ cookiecutter.package_name|upper }}_DEBUG=true {{ cookiecutter.package_name }} --verbose status
+```
+
+## Integration Examples
+
+### Shell Scripts
+
+```bash
+#!/bin/bash
+set -e
+
+# Configuration
+CONFIG_FILE="${CONFIG_FILE:-config/default.yaml}"
+LOG_LEVEL="${LOG_LEVEL:-INFO}"
+
+# Check application health
+if ! {{ cookiecutter.package_name }} --config "$CONFIG_FILE" --log-level "$LOG_LEVEL" status --quiet; then
+    echo "❌ Health check failed" >&2
+    exit 1
+fi
+
+echo "✅ Application is healthy"
+```
+
+### Docker Integration
+
+```dockerfile
+FROM python:3.11-slim
+
+# Install application
+COPY . /app
+WORKDIR /app
+RUN pip install -e .
+
+# Set up configuration
+ENV {{ cookiecutter.package_name|upper }}_CONFIG_FILE=/app/config/docker.yaml
+ENV {{ cookiecutter.package_name|upper }}_LOG_LEVEL=INFO
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD {{ cookiecutter.package_name }} status --quiet || exit 1
+
+# Default command
+CMD ["{{ cookiecutter.package_name }}", "status"]
+```
+
+### CI/CD Integration
+
+```yaml
+# GitHub Actions example
+steps:
+  - name: Install application
+    run: pip install {{ cookiecutter.project_slug }}
+    
+  - name: Validate configuration
+    run: {{ cookiecutter.package_name }} --config config/ci.yaml status
+    
+  - name: Run health check
+    run: {{ cookiecutter.package_name }} status --output json > health.json
+```
+{%- endif %}
\ No newline at end of file
diff --git a/{{cookiecutter.project_slug}}/docs/configuration.md b/{{cookiecutter.project_slug}}/docs/configuration.md
new file mode 100644
index 0000000..85db0c3
--- /dev/null
+++ b/{{cookiecutter.project_slug}}/docs/configuration.md
@@ -0,0 +1,222 @@
+{%- if cookiecutter.docs == 'y' and cookiecutter.typed_config == 'y' %}
+# Configuration
+
+{{ cookiecutter.project_name }} uses a sophisticated configuration system that supports multiple sources and provides type safety when typed configuration is enabled.
+
+## Configuration Hierarchy
+
+Configuration is loaded in the following order (later sources override earlier ones):
+
+1. **Default values** - Built-in sensible defaults
+2. **Configuration file** - YAML or JSON file (auto-detected)  
+3. **Environment variables** - OS environment variables with prefix
+
+## Configuration Sources
+
+### Environment Variables
+
+All environment variables use the prefix `{{ cookiecutter.package_name|upper }}_` followed by the configuration path with double underscores (`__`) for nesting.
+
+Examples:
+```bash
+# Application settings
+{{ cookiecutter.package_name|upper }}_APP__NAME=my-app
+{{ cookiecutter.package_name|upper }}_APP__DEBUG=true
+
+# Logging settings  
+{{ cookiecutter.package_name|upper }}_LOGGING__LEVEL=DEBUG
+{{ cookiecutter.package_name|upper }}_LOGGING__FORMAT=json
+
+# API settings
+{{ cookiecutter.package_name|upper }}_API__TIMEOUT=60
+{{ cookiecutter.package_name|upper }}_API__BASE_URL=https://api.example.com
+
+# Database settings
+{{ cookiecutter.package_name|upper }}_DATABASE__URL=postgresql://localhost/mydb
+{{ cookiecutter.package_name|upper }}_DATABASE__POOL_SIZE=10
+
+# Feature flags
+{{ cookiecutter.package_name|upper }}_FEATURES__CACHING=false
+{{ cookiecutter.package_name|upper }}_FEATURES__METRICS=true
+```
+
+### Configuration File
+
+Create a `config.yaml` (or `config.json`) file in your project root:
+
+```yaml
+app:
+  name: {{ cookiecutter.package_name }}
+  debug: false
+  version: "1.0.0"
+
+logging:
+  level: INFO
+  format: json
+  console_level: INFO
+  file_level: DEBUG
+  file_path: logs/{{ cookiecutter.package_name }}.log
+
+api:
+  timeout: 30
+  max_retries: 3
+  retry_delay: 1.0
+  base_url: null
+
+database:
+  url: null
+  pool_size: 5
+  max_overflow: 10
+
+security:
+  secret_key: null
+  encryption_key: null
+
+features:
+  caching: true
+  metrics: false
+```
+
+### Environment File (.env)
+
+Create a `.env` file for development:
+
+```env
+{{ cookiecutter.package_name|upper }}_APP__DEBUG=true
+{{ cookiecutter.package_name|upper }}_LOGGING__LEVEL=DEBUG
+{{ cookiecutter.package_name|upper }}_API__TIMEOUT=60
+{{ cookiecutter.package_name|upper }}_DATABASE__URL=sqlite:///local.db
+```
+
+## Typed Configuration
+
+With typed configuration enabled, you get:
+
+- **Type safety** - All configuration values are validated
+- **IDE support** - Autocompletion and type hints
+- **Validation** - Automatic validation of configuration values
+- **Documentation** - Built-in field descriptions
+
+### Usage
+
+```python
+from {{ cookiecutter.package_name }}.settings import get_settings, get_app_config
+
+# Get the full settings object
+settings = get_settings()
+print(settings.app.name)
+print(settings.logging.level)
+
+# Or get specific sections
+app_config = get_app_config()
+print(app_config.name)
+print(app_config.debug)
+```
+
+### Configuration Sections
+
+#### App Settings
+```python
+from {{ cookiecutter.package_name }}.settings import get_app_config
+
+app = get_app_config()
+print(f"App: {app.name} v{app.version}")
+if app.debug:
+    print("Debug mode enabled")
+```
+
+#### Logging Settings
+```python
+from {{ cookiecutter.package_name }}.settings import get_logging_config
+
+logging = get_logging_config()
+print(f"Log level: {logging.level}")
+print(f"Log format: {logging.format}")
+```
+
+#### API Settings
+```python
+from {{ cookiecutter.package_name }}.settings import get_api_config
+
+api = get_api_config()
+print(f"API timeout: {api.timeout}s")
+print(f"Max retries: {api.max_retries}")
+```
+
+#### Database Settings
+```python
+from {{ cookiecutter.package_name }}.settings import get_database_config
+
+db = get_database_config()
+if db.url:
+    print(f"Database URL: {db.url}")
+    print(f"Pool size: {db.pool_size}")
+```
+
+#### Feature Flags
+```python
+from {{ cookiecutter.package_name }}.settings import get_feature_config
+
+features = get_feature_config()
+if features.caching:
+    print("Caching is enabled")
+if features.metrics:
+    print("Metrics collection is enabled")
+```
+
+## Legacy Configuration Access
+
+For backwards compatibility, you can still use the traditional configuration API:
+
+```python
+from {{ cookiecutter.package_name }}.config import get_config
+
+config = get_config()
+app_name = config.get('app.name')
+log_level = config.get('logging.level', 'INFO')
+api_timeout = config.get('api.timeout', 30)
+```
+
+## Validation
+
+Typed configuration includes built-in validation:
+
+- **Log levels** must be valid Python logging levels (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+- **Security keys** must be at least 32 characters long  
+- **Numeric values** must be within reasonable ranges
+- **Required fields** are validated at startup
+
+Invalid configuration will raise clear error messages:
+
+```python
+# This will raise a validation error
+settings = Settings(logging__level="INVALID")
+# ValueError: Log level must be one of: DEBUG, INFO, WARNING, ERROR, CRITICAL
+```
+
+## Environment-Specific Configuration
+
+### Development
+```env
+{{ cookiecutter.package_name|upper }}_APP__DEBUG=true
+{{ cookiecutter.package_name|upper }}_LOGGING__LEVEL=DEBUG
+{{ cookiecutter.package_name|upper }}_LOGGING__CONSOLE_LEVEL=DEBUG
+```
+
+### Production
+```env
+{{ cookiecutter.package_name|upper }}_APP__DEBUG=false
+{{ cookiecutter.package_name|upper }}_LOGGING__LEVEL=INFO
+{{ cookiecutter.package_name|upper }}_LOGGING__CONSOLE_LEVEL=WARNING
+{{ cookiecutter.package_name|upper }}_DATABASE__URL=postgresql://prod-server/mydb
+{{ cookiecutter.package_name|upper }}_SECURITY__SECRET_KEY=your-very-secure-32-char-secret-key
+```
+
+### Testing
+```env
+{{ cookiecutter.package_name|upper }}_APP__DEBUG=true
+{{ cookiecutter.package_name|upper }}_LOGGING__LEVEL=WARNING
+{{ cookiecutter.package_name|upper }}_DATABASE__URL=sqlite:///test.db
+{{ cookiecutter.package_name|upper }}_FEATURES__CACHING=false
+```
+{%- endif %}
\ No newline at end of file
diff --git a/{{cookiecutter.project_slug}}/mkdocs.yml b/{{cookiecutter.project_slug}}/mkdocs.yml
index 4bcdcfd..e7c93a5 100644
--- a/{{cookiecutter.project_slug}}/mkdocs.yml
+++ b/{{cookiecutter.project_slug}}/mkdocs.yml
@@ -1,3 +1,4 @@
+{%- if cookiecutter.docs == 'y' %}
 site_name: {{cookiecutter.project_name}}
 site_description: {{cookiecutter.project_description}}
 site_author: {{cookiecutter.author_name}}
@@ -37,6 +38,12 @@ theme:
 nav:
   - Home: index.md
   - Contributing: contributing.md
+  {%- if cookiecutter.typed_config == 'y' %}
+  - Configuration: configuration.md
+  {%- endif %}
+  {%- if cookiecutter.project_type == "cli-application" %}
+  - CLI Usage: cli-usage.md
+  {%- endif %}
 
 plugins:
   - search
@@ -69,3 +76,4 @@ extra:
       link: https://github.com/{{cookiecutter.github_username}}
     - icon: fontawesome/brands/python
       link: https://pypi.org/project/{{cookiecutter.project_slug}}/
+{%- endif %}
diff --git a/{{cookiecutter.project_slug}}/pyproject.toml b/{{cookiecutter.project_slug}}/pyproject.toml
index 02d24d3..50cad15 100644
--- a/{{cookiecutter.project_slug}}/pyproject.toml
+++ b/{{cookiecutter.project_slug}}/pyproject.toml
@@ -1,10 +1,21 @@
 [build-system]
+{%- if cookiecutter.package_manager == "hatch" %}
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+{%- else %}
 requires = ["setuptools>=61.0", "wheel"]
 build-backend = "setuptools.build_meta"
+{%- endif %}
 
 [project]
 name = "{{cookiecutter.project_slug}}"
+{%- if cookiecutter.versioning == "setuptools-scm" %}
+dynamic = ["version"]
+{%- elif cookiecutter.versioning == "hatch" and cookiecutter.package_manager == "hatch" %}
 dynamic = ["version"]
+{%- else %}
+version = "0.1.0"
+{%- endif %}
 description = "{{cookiecutter.project_description}}"
 authors = [
     {name = "{{cookiecutter.author_name}}", email = "{{cookiecutter.author_email}}"},
@@ -43,6 +54,10 @@ dependencies = [
     "rich>=13.0.0",
     "click-man>=0.4.1",
     {%- endif %}
+    {%- if cookiecutter.typed_config == 'y' %}
+    "pydantic>=2.0.0",
+    "pydantic-settings>=2.0.0",
+    {%- endif %}
 ]
 
 [project.optional-dependencies]
@@ -53,10 +68,16 @@ dev = [
     "mypy>=1.10.0",
     "types-pyyaml>=6.0.0",
     "build>=1.0.0",
+    {%- if cookiecutter.docs == 'y' %}
     "mkdocs-material>=9.5.0",
+    "mkdocstrings[python]>=0.24.0",
+    {%- endif %}
     {%- if cookiecutter.include_pre_commit == 'y' %}
     "pre-commit>=3.7.0",
     {%- endif %}
+    {%- if cookiecutter.typed_config == 'y' %}
+    "types-pydantic>=2.0.0",
+    {%- endif %}
 ]
 
 {%- if cookiecutter.project_type == "cli-application" %}
@@ -68,15 +89,43 @@ dev = [
 [project.urls]
 Homepage = "https://github.com/{{ cookiecutter.github_username }}/{{ cookiecutter.project_slug }}"
 Repository = "https://github.com/{{ cookiecutter.github_username }}/{{ cookiecutter.project_slug }}"
+{%- if cookiecutter.docs == 'y' %}
 Documentation = "https://{{ cookiecutter.github_username }}.github.io/{{ cookiecutter.project_slug }}"
+{%- endif %}
 Issues = "https://github.com/{{ cookiecutter.github_username }}/{{ cookiecutter.project_slug }}/issues"
 
+{%- if cookiecutter.package_manager != "hatch" %}
 [tool.setuptools.packages.find]
 where = ["src"]
+{%- endif %}
 
+{%- if cookiecutter.versioning == "setuptools-scm" %}
 [tool.setuptools.dynamic]
 version = {attr = "{{cookiecutter.package_name}}.__version__"}
 
+[tool.setuptools_scm]
+version_scheme = "guess-next-dev"
+local_scheme = "dirty-tag"
+write_to = "src/{{cookiecutter.package_name}}/_version.py"
+{%- elif cookiecutter.package_manager == "hatch" and cookiecutter.versioning == "hatch" %}
+[tool.hatch.version]
+path = "src/{{cookiecutter.package_name}}/__init__.py"
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src",
+    "/tests",
+    "/README.md",
+    "/LICENSE",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/{{cookiecutter.package_name}}"]
+{%- elif cookiecutter.package_manager != "hatch" and cookiecutter.versioning != "setuptools-scm" %}
+[tool.setuptools.dynamic]
+version = {attr = "{{cookiecutter.package_name}}.__version__"}
+{%- endif %}
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]
diff --git a/{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/config.py b/{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/config.py
index 9f90f64..cf92c7e 100644
--- a/{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/config.py
+++ b/{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/config.py
@@ -5,6 +5,11 @@
 DEFAULTS < CONFIG_FILE < Environment Variables
 
 Environment variables take precedence over config file, which takes precedence over defaults.
+{%- if cookiecutter.typed_config == 'y' %}
+
+When typed_config is enabled, this module provides compatibility with Pydantic settings
+while maintaining the existing API for backward compatibility.
+{%- endif %}
 """
 
 import os
@@ -15,6 +20,15 @@
 
 from .logger import get_logger
 
+{%- if cookiecutter.typed_config == 'y' %}
+# Conditional import for typed configuration
+try:
+    from .settings import get_settings
+    TYPED_CONFIG_AVAILABLE = True
+except ImportError:
+    TYPED_CONFIG_AVAILABLE = False
+{%- endif %}
+
 # Initialize logger for this module
 logger = get_logger(__name__)
 
@@ -330,11 +344,65 @@ def get_config() -> Config:
     """
     global _config_instance  # noqa: PLW0603
     if _config_instance is None:
+{%- if cookiecutter.typed_config == 'y' %}
+        # Use typed config if available, fallback to traditional config
+        if TYPED_CONFIG_AVAILABLE:
+            _config_instance = TypedConfigAdapter()
+        else:
+            _config_instance = Config()
+{%- else %}
         _config_instance = Config()
+{%- endif %}
     return _config_instance
 
 
 def reload_config():
     """Force reload of the configuration (useful for testing or config changes)."""
     global _config_instance  # noqa: PLW0603
+{%- if cookiecutter.typed_config == 'y' %}
+    if TYPED_CONFIG_AVAILABLE:
+        _config_instance = TypedConfigAdapter()
+    else:
+        _config_instance = Config()
+{%- else %}
     _config_instance = Config()
+{%- endif %}
+
+
+{%- if cookiecutter.typed_config == 'y' %}
+
+
+class TypedConfigAdapter(Config):
+    """
+    Adapter class that provides backward compatibility with typed Pydantic settings.
+    
+    This allows existing code to continue using the Config API while benefiting
+    from type safety and validation when typed_config is enabled.
+    """
+    
+    def __init__(self):
+        """Initialize the typed config adapter."""
+        self.logger = get_logger(f"{__name__}.{self.__class__.__name__}")
+        self.logger.info("Using typed Pydantic configuration")
+        
+        try:
+            self._settings = get_settings()
+            self._config = self._settings.get_legacy_dict()
+            self.logger.info("✅ Typed configuration loaded successfully")
+        except Exception as e:
+            self.logger.error(f"❌ Failed to load typed config, falling back to traditional config: {e}")
+            # Fallback to traditional config
+            super().__init__()
+    
+    def reload(self):
+        """Reload configuration from typed settings."""
+        try:
+            # Clear the cached settings and reload
+            get_settings.cache_clear()
+            self._settings = get_settings()
+            self._config = self._settings.get_legacy_dict()
+            self.logger.info("✅ Typed configuration reloaded")
+        except Exception as e:
+            self.logger.error(f"❌ Failed to reload typed config: {e}")
+            super().reload()
+{%- endif %}
diff --git a/{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/logger.py b/{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/logger.py
index 1ee26fd..3dd4ce8 100644
--- a/{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/logger.py
+++ b/{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/logger.py
@@ -2,7 +2,8 @@
 Enhanced modular logger configuration for {{ cookiecutter.package_name }}.
 
 This module provides a centralized, secure, and performant logging system
-with thread safety, sensitive data filtering, and configuration integration.
+with thread safety, sensitive data filtering, JSON formatting, and
+request/operation ID tracking for better observability.
 """
 
 import json
@@ -12,10 +13,16 @@
 import re
 import sys
 import threading
+import uuid
+from contextvars import ContextVar
 from datetime import datetime
 from pathlib import Path
 from typing import Any, ClassVar
 
+# Context variables for request/operation tracking
+request_id_context: ContextVar[str] = ContextVar('request_id', default='')
+operation_id_context: ContextVar[str] = ContextVar('operation_id', default='')
+
 
 class SensitiveDataFilter(logging.Filter):
     """Filter to sanitize sensitive information from log records."""
@@ -158,7 +165,7 @@ def format(self, record):
 
 
 class JSONFormatter(logging.Formatter):
-    """JSON formatter for structured logging."""
+    """JSON formatter for structured logging with request/operation ID support."""
 
     def format(self, record: logging.LogRecord) -> str:
         log_obj = {
@@ -174,6 +181,15 @@ def format(self, record: logging.LogRecord) -> str:
             'thread_name': record.threadName,
         }
 
+        # Add request/operation context if available
+        request_id = request_id_context.get()
+        if request_id:
+            log_obj['request_id'] = request_id
+
+        operation_id = operation_id_context.get()
+        if operation_id:
+            log_obj['operation_id'] = operation_id
+
         # Add exception info if present
         if record.exc_info:
             log_obj['exception'] = self.formatException(record.exc_info)
@@ -511,6 +527,83 @@ def critical(message: str, *args, **kwargs):
     _{{ cookiecutter.package_name }}_logger.get_logger().critical(message, *args, **kwargs)
 
 
+# Request/Operation ID context management
+def set_request_id(request_id: str | None = None) -> str:
+    """
+    Set the request ID for the current context.
+    
+    Args:
+        request_id: Request ID to set. If None, generates a new UUID4.
+        
+    Returns:
+        str: The set request ID
+    """
+    if request_id is None:
+        request_id = str(uuid.uuid4())
+    request_id_context.set(request_id)
+    return request_id
+
+
+def get_request_id() -> str:
+    """Get the current request ID from context."""
+    return request_id_context.get('')
+
+
+def set_operation_id(operation_id: str | None = None) -> str:
+    """
+    Set the operation ID for the current context.
+    
+    Args:
+        operation_id: Operation ID to set. If None, generates a new UUID4.
+        
+    Returns:
+        str: The set operation ID
+    """
+    if operation_id is None:
+        operation_id = str(uuid.uuid4())
+    operation_id_context.set(operation_id)
+    return operation_id
+
+
+def get_operation_id() -> str:
+    """Get the current operation ID from context."""
+    return operation_id_context.get('')
+
+
+def clear_context():
+    """Clear all logging context (request and operation IDs)."""
+    request_id_context.set('')
+    operation_id_context.set('')
+
+
+class LoggingContext:
+    """Context manager for setting request/operation IDs."""
+    
+    def __init__(self, request_id: str | None = None, operation_id: str | None = None):
+        self.request_id = request_id
+        self.operation_id = operation_id
+        self.previous_request_id = ''
+        self.previous_operation_id = ''
+    
+    def __enter__(self):
+        # Store previous values
+        self.previous_request_id = get_request_id()
+        self.previous_operation_id = get_operation_id()
+        
+        # Set new values
+        if self.request_id is not None:
+            set_request_id(self.request_id)
+        if self.operation_id is not None:
+            set_operation_id(self.operation_id)
+        
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # Restore previous values
+        request_id_context.set(self.previous_request_id)
+        operation_id_context.set(self.previous_operation_id)
+
+
 if __name__ == "__main__":
     # Test the logger
     logger = get_logger(__name__)
diff --git a/{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/settings.py b/{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/settings.py
new file mode 100644
index 0000000..5f5a51e
--- /dev/null
+++ b/{{cookiecutter.project_slug}}/src/{{cookiecutter.package_name}}/settings.py
@@ -0,0 +1,182 @@
+"""
+Typed configuration settings for {{ cookiecutter.package_name }} using Pydantic.
+
+This module provides type-safe configuration management with automatic validation,
+environment variable loading, and IDE autocompletion support.
+"""
+
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from .logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class LoggingSettings(BaseSettings):
+    """Logging configuration settings."""
+    
+    level: str = Field(default="INFO", description="Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)")
+    format: str = Field(default="json", description="Log format (json or plain)")
+    console_level: str = Field(default="INFO", description="Console log level")
+    file_level: str = Field(default="DEBUG", description="File log level")
+    file_path: str = Field(default="logs/{{ cookiecutter.package_name }}.log", description="Log file path")
+    max_file_size: str = Field(default="10MB", description="Maximum log file size")
+    backup_count: int = Field(default=5, description="Number of backup log files")
+    
+    @field_validator('level', 'console_level', 'file_level')
+    @classmethod
+    def validate_log_level(cls, v: str) -> str:
+        """Validate log level values."""
+        valid_levels = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
+        if v.upper() not in valid_levels:
+            raise ValueError(f"Log level must be one of: {', '.join(valid_levels)}")
+        return v.upper()
+    
+    @field_validator('format')
+    @classmethod
+    def validate_log_format(cls, v: str) -> str:
+        """Validate log format values."""
+        if v not in ["json", "plain"]:
+            raise ValueError("Log format must be 'json' or 'plain'")
+        return v
+
+
+class ApiSettings(BaseSettings):
+    """API configuration settings."""
+    
+    timeout: int = Field(default=30, description="API request timeout in seconds", ge=1)
+    max_retries: int = Field(default=3, description="Maximum number of retries", ge=0)
+    retry_delay: float = Field(default=1.0, description="Delay between retries in seconds", ge=0)
+    base_url: str | None = Field(default=None, description="Base URL for API requests")
+
+
+class DatabaseSettings(BaseSettings):
+    """Database configuration settings."""
+    
+    url: str | None = Field(default=None, description="Database connection URL")
+    pool_size: int = Field(default=5, description="Connection pool size", ge=1)
+    max_overflow: int = Field(default=10, description="Maximum pool overflow", ge=0)
+    pool_timeout: int = Field(default=30, description="Pool timeout in seconds", ge=1)
+
+
+class SecuritySettings(BaseSettings):
+    """Security configuration settings."""
+    
+    secret_key: str | None = Field(default=None, description="Secret key for encryption")
+    encryption_key: str | None = Field(default=None, description="Encryption key")
+    
+    @field_validator('secret_key', 'encryption_key')
+    @classmethod
+    def validate_key_length(cls, v: str | None) -> str | None:
+        """Validate key lengths for security."""
+        if v is not None and len(v) < 32:
+            raise ValueError("Security keys must be at least 32 characters long")
+        return v
+
+
+class FeatureSettings(BaseSettings):
+    """Feature flag settings."""
+    
+    caching: bool = Field(default=True, description="Enable caching")
+    metrics: bool = Field(default=False, description="Enable metrics collection")
+
+
+class AppSettings(BaseSettings):
+    """Application settings."""
+    
+    name: str = Field(default="{{ cookiecutter.package_name }}", description="Application name")
+    version: str = Field(default="1.0.0", description="Application version")
+    debug: bool = Field(default=False, description="Debug mode")
+
+
+class Settings(BaseSettings):
+    """Main settings class combining all configuration sections."""
+    
+    model_config = SettingsConfigDict(
+        # Load from environment variables with prefix
+        env_prefix="{{ cookiecutter.package_name|upper }}_",
+        env_nested_delimiter="__",  # Use double underscore for nested settings
+        # Load from .env file
+        env_file=".env",
+        env_file_encoding="utf-8",
+        # Case sensitivity
+        case_sensitive=False,
+        # Allow extra fields for extensibility
+        extra="allow",
+    )
+    
+    # Configuration sections
+    logging: LoggingSettings = Field(default_factory=LoggingSettings)
+    api: ApiSettings = Field(default_factory=ApiSettings)
+    database: DatabaseSettings = Field(default_factory=DatabaseSettings)
+    security: SecuritySettings = Field(default_factory=SecuritySettings)
+    features: FeatureSettings = Field(default_factory=FeatureSettings)
+    app: AppSettings = Field(default_factory=AppSettings)
+    
+    def __init__(self, **kwargs):
+        """Initialize settings with config file loading."""
+        super().__init__(**kwargs)
+        logger.info("✅ Typed configuration loaded successfully")
+    
+    def get_legacy_dict(self) -> dict[str, Any]:
+        """
+        Convert to legacy dictionary format for compatibility.
+        
+        This method provides backward compatibility with the existing
+        config.py module's dictionary-based access patterns.
+        """
+        return {
+            "logging": self.logging.model_dump(),
+            "api": self.api.model_dump(),
+            "database": self.database.model_dump(),
+            "security": self.security.model_dump(),
+            "features": self.features.model_dump(),
+            "app": self.app.model_dump(),
+        }
+
+
+@lru_cache()
+def get_settings() -> Settings:
+    """
+    Get the global settings instance (cached singleton).
+    
+    Returns:
+        Settings: The typed settings instance
+    """
+    return Settings()
+
+
+# Convenience functions for common access patterns
+def get_logging_config() -> LoggingSettings:
+    """Get logging configuration."""
+    return get_settings().logging
+
+
+def get_api_config() -> ApiSettings:
+    """Get API configuration."""
+    return get_settings().api
+
+
+def get_database_config() -> DatabaseSettings:
+    """Get database configuration."""
+    return get_settings().database
+
+
+def get_security_config() -> SecuritySettings:
+    """Get security configuration."""
+    return get_settings().security
+
+
+def get_feature_config() -> FeatureSettings:
+    """Get feature flags."""
+    return get_settings().features
+
+
+def get_app_config() -> AppSettings:
+    """Get application configuration."""
+    return get_settings().app
\ No newline at end of file
diff --git a/{{cookiecutter.project_slug}}/tests/test_settings.py b/{{cookiecutter.project_slug}}/tests/test_settings.py
new file mode 100644
index 0000000..3a6f927
--- /dev/null
+++ b/{{cookiecutter.project_slug}}/tests/test_settings.py
@@ -0,0 +1,171 @@
+"""
+Tests for typed configuration (Pydantic settings) functionality.
+
+These tests only run when typed_config is enabled in cookiecutter options.
+"""
+
+import os
+import tempfile
+from pathlib import Path
+
+import pytest
+
+{%- if cookiecutter.typed_config == 'y' %}
+
+from {{ cookiecutter.package_name }}.settings import (
+    ApiSettings,
+    AppSettings,
+    DatabaseSettings,
+    FeatureSettings,
+    LoggingSettings,
+    SecuritySettings,
+    Settings,
+    get_settings,
+)
+
+
+class TestTypedSettings:
+    """Test suite for typed Pydantic settings."""
+
+    def test_default_settings(self):
+        """Test that default settings load correctly."""
+        settings = Settings()
+        
+        assert settings.app.name == "{{ cookiecutter.package_name }}"
+        assert settings.app.version == "1.0.0"
+        assert settings.app.debug is False
+        
+        assert settings.logging.level == "INFO"
+        assert settings.logging.format == "json"
+        
+        assert settings.api.timeout == 30
+        assert settings.api.max_retries == 3
+        
+        assert settings.features.caching is True
+        assert settings.features.metrics is False
+
+    def test_environment_variable_loading(self, monkeypatch):
+        """Test that environment variables are loaded correctly."""
+        # Set environment variables with the correct prefix
+        monkeypatch.setenv("{{ cookiecutter.package_name|upper }}_APP__NAME", "test-app")
+        monkeypatch.setenv("{{ cookiecutter.package_name|upper }}_APP__DEBUG", "true")
+        monkeypatch.setenv("{{ cookiecutter.package_name|upper }}_LOGGING__LEVEL", "DEBUG")
+        monkeypatch.setenv("{{ cookiecutter.package_name|upper }}_API__TIMEOUT", "60")
+        monkeypatch.setenv("{{ cookiecutter.package_name|upper }}_FEATURES__CACHING", "false")
+        
+        settings = Settings()
+        
+        assert settings.app.name == "test-app"
+        assert settings.app.debug is True
+        assert settings.logging.level == "DEBUG"
+        assert settings.api.timeout == 60
+        assert settings.features.caching is False
+
+    def test_dotenv_file_loading(self, tmp_path):
+        """Test that .env file is loaded correctly."""
+        env_file = tmp_path / ".env"
+        env_file.write_text("""
+{{ cookiecutter.package_name|upper }}_APP__NAME=env-test-app
+{{ cookiecutter.package_name|upper }}_APP__DEBUG=true
+{{ cookiecutter.package_name|upper }}_LOGGING__LEVEL=WARNING
+{{ cookiecutter.package_name|upper }}_API__MAX_RETRIES=5
+""")
+        
+        # Change to temp directory so .env is found
+        original_cwd = Path.cwd()
+        os.chdir(tmp_path)
+        
+        try:
+            settings = Settings()
+            assert settings.app.name == "env-test-app"
+            assert settings.app.debug is True
+            assert settings.logging.level == "WARNING"
+            assert settings.api.max_retries == 5
+        finally:
+            os.chdir(original_cwd)
+
+    def test_validation_errors(self):
+        """Test that validation errors are raised for invalid values."""
+        with pytest.raises(ValueError, match="Log level must be one of"):
+            LoggingSettings(level="INVALID")
+        
+        with pytest.raises(ValueError, match="Log format must be"):
+            LoggingSettings(format="invalid")
+        
+        with pytest.raises(ValueError, match="Security keys must be at least"):
+            SecuritySettings(secret_key="short")
+
+    def test_legacy_dict_compatibility(self):
+        """Test that settings can be converted to legacy dict format."""
+        settings = Settings()
+        legacy_dict = settings.get_legacy_dict()
+        
+        assert isinstance(legacy_dict, dict)
+        assert "app" in legacy_dict
+        assert "logging" in legacy_dict
+        assert "api" in legacy_dict
+        assert "database" in legacy_dict
+        assert "security" in legacy_dict
+        assert "features" in legacy_dict
+        
+        # Check nested structure
+        assert legacy_dict["app"]["name"] == "{{ cookiecutter.package_name }}"
+        assert legacy_dict["logging"]["level"] == "INFO"
+        assert legacy_dict["api"]["timeout"] == 30
+
+    def test_get_settings_singleton(self):
+        """Test that get_settings returns a singleton."""
+        # Clear cache first
+        get_settings.cache_clear()
+        
+        settings1 = get_settings()
+        settings2 = get_settings()
+        
+        # Should be the same object due to caching
+        assert settings1 is settings2
+
+    def test_convenience_functions(self):
+        """Test convenience functions for accessing settings sections."""
+        from {{ cookiecutter.package_name }}.settings import (
+            get_api_config,
+            get_app_config,
+            get_database_config,
+            get_feature_config,
+            get_logging_config,
+            get_security_config,
+        )
+        
+        app_config = get_app_config()
+        assert isinstance(app_config, AppSettings)
+        assert app_config.name == "{{ cookiecutter.package_name }}"
+        
+        logging_config = get_logging_config()
+        assert isinstance(logging_config, LoggingSettings)
+        assert logging_config.level == "INFO"
+        
+        api_config = get_api_config()
+        assert isinstance(api_config, ApiSettings)
+        assert api_config.timeout == 30
+        
+        db_config = get_database_config()
+        assert isinstance(db_config, DatabaseSettings)
+        assert db_config.pool_size == 5
+        
+        security_config = get_security_config()
+        assert isinstance(security_config, SecuritySettings)
+        
+        feature_config = get_feature_config()
+        assert isinstance(feature_config, FeatureSettings)
+        assert feature_config.caching is True
+
+
+{%- else %}
+
+# Placeholder tests when typed_config is disabled
+def test_typed_config_disabled():
+    """Test that typed config is disabled."""
+    # This is a placeholder test that always passes
+    # when typed_config is disabled
+    assert True
+
+{%- endif %}
\ No newline at end of file