diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 45716b9..e400007 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -21,25 +21,46 @@ You are working on the ioBroker Copilot Instructions template repository. This r
 - `README.md` - Repository documentation explaining how to use the template  
 - `CHANGELOG.md` - Version history and detailed change documentation
 - `TESTING.md` - Automated testing infrastructure documentation
+- `config/metadata.json` - **CENTRALIZED VERSION REGISTRY** - Contains all component versions and deployment configuration
 - `scripts/check-template-version.sh` - Version checking utility for users
-- `scripts/manage-versions.sh` - Master version management script (show/check/sync/update commands)
+- `scripts/manage-versions.sh` - **Enhanced version management** (show/check/sync/update/update-component/list-components commands)
 - `scripts/extract-version.sh` - Dynamic version extraction from template and current dates
 - `scripts/update-versions.sh` - Automated documentation synchronization script
+- `scripts/shared-utils.sh` - **Enhanced with component version functions** for metadata access
 - `tests/test-runner.sh` - Main test execution framework for all scripts
 - `tests/test-*.sh` - Comprehensive test suites for each script and integration scenarios
+- `tests/test-version-separation.sh` - **NEW** - Tests for multi-component versioning system
 - `.github/workflows/test-scripts.yml` - GitHub Actions workflow for continuous testing
+- `.github/workflows/deploy-on-version-change.yml` - **NEW** - Automated deployment on main version changes
 - `.github/copilot-instructions.md` - THIS file - repository-specific instructions
 
 ## Template Development Guidelines
 
 ### Version Management
-- Use the dynamic version management system (`scripts/manage-versions.sh`) for all version updates
-- Update versions with: `./scripts/manage-versions.sh update X.Y.Z` (automatically updates all files)
+- **Enhanced Multi-Component Versioning**: Repository now supports independent versioning for templates, GitHub Actions, and other components
+- **Main Package Version**: Always tied to template version and triggers automated deployment when changed
+- **Component Updates**: Use `./scripts/manage-versions.sh update-component <component_path> <version>` for individual component versions
+- **Version Policy Enforcement**: All version changes must be incremental (higher than previous version)
+- **Centralized Configuration**: All version information stored in `config/metadata.json` with full component tracking
+- **Main Version Updates**: Use `./scripts/manage-versions.sh update X.Y.Z` (automatically updates template and package versions together)
+- **Version Validation**: Built-in checks ensure main version matches template version and prevents downgrades
+- **Automated Deployment**: Changes to main version trigger deployment workflow automatically
 - Document all changes in `CHANGELOG.md` with detailed descriptions
-- Use semantic versioning (MAJOR.MINOR.PATCH)
+- Use semantic versioning (MAJOR.MINOR.PATCH) for all components
 - Validate consistency with: `./scripts/manage-versions.sh check`
 - Sync documentation with: `./scripts/manage-versions.sh sync` when needed
 
+### GitHub Copilot Review Instructions for Version Changes
+When reviewing PRs that modify versions:
+1. **Always verify main version changes match template version** - these must be identical
+2. **Check that version increments are higher than previous** - prevent downgrades
+3. **Validate component version changes** - ensure they follow semantic versioning
+4. **Confirm CHANGELOG.md is updated** - require detailed change documentation
+5. **Check for deployment readiness** - main version changes trigger automated deployment
+6. **Review version policy compliance** - ensure all changes follow increment requirements
+7. **Validate metadata consistency** - run `./scripts/manage-versions.sh check` mentally
+8. **Component separation compliance** - ensure components use independent versioning appropriately
+
 ### Template Content Standards  
 - Focus on practical, actionable guidance for ioBroker adapter developers
 - Include comprehensive examples with real code snippets
diff --git a/.github/workflows/deploy-on-version-change.yml b/.github/workflows/deploy-on-version-change.yml
new file mode 100644
index 0000000..f3c8a8f
--- /dev/null
+++ b/.github/workflows/deploy-on-version-change.yml
@@ -0,0 +1,208 @@
+name: Deploy on Version Change
+
+on:
+  push:
+    branches: [ main ]
+    paths:
+      - 'config/metadata.json'
+      - 'template.md'
+      - 'package.json'
+  workflow_dispatch:
+    inputs:
+      force_deploy:
+        description: 'Force deployment regardless of version change'
+        required: false
+        default: 'false'
+        type: boolean
+
+jobs:
+  detect-version-change:
+    runs-on: ubuntu-latest
+    outputs:
+      version_changed: ${{ steps.check-version.outputs.changed }}
+      old_version: ${{ steps.check-version.outputs.old_version }}
+      new_version: ${{ steps.check-version.outputs.new_version }}
+      deploy_needed: ${{ steps.check-version.outputs.deploy_needed }}
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2  # Need previous commit to compare
+      
+      - name: Check for version changes
+        id: check-version
+        run: |
+          echo "🔍 Checking for main version changes..."
+          
+          # Get current version from metadata
+          CURRENT_VERSION=$(jq -r '.version' config/metadata.json)
+          echo "Current version: $CURRENT_VERSION"
+          
+          # Get previous version from git (if available)
+          if git show HEAD~1:config/metadata.json >/dev/null 2>&1; then
+            PREVIOUS_VERSION=$(git show HEAD~1:config/metadata.json | jq -r '.version' 2>/dev/null || echo "unknown")
+            echo "Previous version: $PREVIOUS_VERSION"
+          else
+            PREVIOUS_VERSION="unknown"
+            echo "Previous version: unknown (no previous commit)"
+          fi
+          
+          # Set outputs
+          echo "old_version=$PREVIOUS_VERSION" >> $GITHUB_OUTPUT
+          echo "new_version=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+          
+          # Check if deployment is needed
+          DEPLOY_NEEDED="false"
+          
+          if [[ "${{ github.event.inputs.force_deploy }}" == "true" ]]; then
+            echo "🚀 Force deployment requested"
+            DEPLOY_NEEDED="true"
+          elif [[ "$PREVIOUS_VERSION" != "$CURRENT_VERSION" ]]; then
+            echo "🔄 Version changed from $PREVIOUS_VERSION to $CURRENT_VERSION"
+            DEPLOY_NEEDED="true"
+          else
+            echo "⏸️  No version change detected"
+          fi
+          
+          echo "deploy_needed=$DEPLOY_NEEDED" >> $GITHUB_OUTPUT
+          echo "changed=$DEPLOY_NEEDED" >> $GITHUB_OUTPUT
+          
+          if [[ "$DEPLOY_NEEDED" == "true" ]]; then
+            echo "✅ Deployment will proceed"
+          else
+            echo "⏭️  Skipping deployment"
+          fi
+
+  validate-version-policy:
+    needs: detect-version-change
+    if: needs.detect-version-change.outputs.deploy_needed == 'true'
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      
+      - name: Validate version increment policy
+        run: |
+          echo "🔍 Validating version increment policy..."
+          
+          OLD_VERSION="${{ needs.detect-version-change.outputs.old_version }}"
+          NEW_VERSION="${{ needs.detect-version-change.outputs.new_version }}"
+          
+          # Make script executable
+          chmod +x scripts/manage-versions.sh
+          
+          # Validate increment policy
+          if ./scripts/manage-versions.sh validate-increment "main" "$OLD_VERSION" "$NEW_VERSION"; then
+            echo "✅ Version increment validation passed"
+          else
+            echo "❌ Version increment validation failed"
+            exit 1
+          fi
+      
+      - name: Validate metadata consistency
+        run: |
+          echo "🔍 Validating metadata and file consistency..."
+          
+          # Run consistency check
+          if ./scripts/manage-versions.sh check; then
+            echo "✅ Version consistency validation passed"
+          else
+            echo "❌ Version consistency validation failed"
+            echo ""
+            echo "💡 Run './scripts/manage-versions.sh sync' to fix inconsistencies"
+            exit 1
+          fi
+
+  deploy-package:
+    needs: [detect-version-change, validate-version-policy]
+    if: needs.detect-version-change.outputs.deploy_needed == 'true'
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout repository  
+        uses: actions/checkout@v4
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+      
+      - name: Run test suite
+        run: |
+          echo "🧪 Running complete test suite before deployment..."
+          chmod +x tests/test-runner.sh scripts/*.sh
+          
+          if ./tests/test-runner.sh; then
+            echo "✅ All tests passed"
+          else
+            echo "❌ Tests failed - deployment aborted"
+            exit 1
+          fi
+      
+      - name: Create release tag
+        run: |
+          NEW_VERSION="${{ needs.detect-version-change.outputs.new_version }}"
+          echo "🏷️  Creating release tag v$NEW_VERSION"
+          
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          
+          # Create annotated tag with version info using a here-document
+          cat <<EOF > /tmp/tag-message.txt
+Release version $NEW_VERSION
+
+Package version: $NEW_VERSION
+Template version: $NEW_VERSION
+
+Automated deployment triggered by version change in config/metadata.json
+Previous version: ${{ needs.detect-version-change.outputs.old_version }}
+
+See CHANGELOG.md for detailed changes.
+EOF
+          git tag -a "v$NEW_VERSION" -F /tmp/tag-message.txt
+          git push origin "v$NEW_VERSION"
+      
+      - name: Generate deployment summary
+        run: |
+          echo "# 🚀 Deployment Summary" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "| Item | Value |" >> $GITHUB_STEP_SUMMARY
+          echo "|------|-------|" >> $GITHUB_STEP_SUMMARY
+          echo "| Previous Version | ${{ needs.detect-version-change.outputs.old_version }} |" >> $GITHUB_STEP_SUMMARY
+          echo "| New Version | ${{ needs.detect-version-change.outputs.new_version }} |" >> $GITHUB_STEP_SUMMARY
+          echo "| Trigger | ${{ github.event_name }} |" >> $GITHUB_STEP_SUMMARY
+          echo "| Git Tag | v${{ needs.detect-version-change.outputs.new_version }} |" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "## ✅ Validation Status" >> $GITHUB_STEP_SUMMARY
+          echo "- Version increment policy: ✅ Passed" >> $GITHUB_STEP_SUMMARY
+          echo "- Metadata consistency: ✅ Passed" >> $GITHUB_STEP_SUMMARY
+          echo "- Test suite: ✅ Passed" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "## 📦 Components" >> $GITHUB_STEP_SUMMARY
+          echo "Main template and package versions have been updated to ${{ needs.detect-version-change.outputs.new_version }}" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "Individual component versions remain independent and can be updated separately using:" >> $GITHUB_STEP_SUMMARY
+          echo '`./scripts/manage-versions.sh update-component <component> <version>`' >> $GITHUB_STEP_SUMMARY
+
+  notify-completion:
+    needs: [detect-version-change, deploy-package]
+    if: always() && needs.detect-version-change.outputs.deploy_needed == 'true'
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Deployment success notification
+        if: needs.deploy-package.result == 'success'
+        run: |
+          echo "🎉 Deployment completed successfully!"
+          echo "New version: ${{ needs.detect-version-change.outputs.new_version }}"
+          echo "Git tag: v${{ needs.detect-version-change.outputs.new_version }}"
+      
+      - name: Deployment failure notification  
+        if: needs.deploy-package.result == 'failure'
+        run: |
+          echo "❌ Deployment failed!"
+          echo "Version: ${{ needs.detect-version-change.outputs.new_version }}"
+          echo "Please check the workflow logs and fix any issues."
+          exit 1
\ No newline at end of file
diff --git a/config/metadata.json b/config/metadata.json
index 41cde27..bf9e8af 100644
--- a/config/metadata.json
+++ b/config/metadata.json
@@ -1,12 +1,14 @@
 {
   "version": "0.4.0",
+  "warning": "⚠️  CHANGING THE MAIN VERSION ABOVE WILL TRIGGER AUTOMATED PACKAGE UPDATE DEPLOYMENT",
   "repository": {
     "url": "https://github.com/DrozmotiX/ioBroker-Copilot-Instructions",
     "raw_base": "https://raw.githubusercontent.com/DrozmotiX/ioBroker-Copilot-Instructions/main"
   },
   "template": {
     "file": "template.md",
-    "target_path": ".github/copilot-instructions.md"
+    "target_path": ".github/copilot-instructions.md",
+    "version": "0.4.0"
   },
   "scripts": {
     "check_template_version": "scripts/check-template-version.sh",
@@ -19,5 +21,55 @@
       "template-update",
       "automation"
     ]
+  },
+  "components": {
+    "github_actions": {
+      "weekly_version_check": {
+        "file": "templates/weekly-version-check-action.yml",
+        "version": "0.2.1",
+        "description": "GitHub Action for automated template version monitoring"
+      },
+      "github_action_snippet": {
+        "file": "snippets/github-action-version-check.yml",
+        "version": "0.2.0",
+        "description": "Reusable GitHub Action snippet for template checking"
+      }
+    },
+    "templates": {
+      "initial_setup_automation": {
+        "file": "templates/initial-setup-automation.md",
+        "version": "0.3.0",
+        "description": "Automated setup template with GitHub Copilot integration"
+      },
+      "copy_paste_template": {
+        "file": "templates/copy-paste-template.md",
+        "version": "0.2.0",
+        "description": "Quick template update guide for GitHub Copilot"
+      },
+      "automated_template_update": {
+        "file": "templates/automated-template-update.md",
+        "version": "0.2.0",
+        "description": "Automated template update instructions"
+      }
+    },
+    "snippets": {
+      "version_check_command": {
+        "file": "snippets/version-check-command.md",
+        "version": "0.1.1",
+        "description": "Reusable version check command snippet"
+      },
+      "version_management_commands": {
+        "file": "snippets/version-management-commands.md",
+        "version": "0.1.0",
+        "description": "Version management script usage examples"
+      }
+    }
+  },
+  "version_policy": {
+    "main_version_source": "template.version",
+    "main_version_description": "Main package version must always match template version",
+    "component_versioning": "independent",
+    "increment_policy": "must_be_higher_than_previous",
+    "deployment_trigger": "main_version_change"
   }
 }
diff --git a/scripts/manage-versions.sh b/scripts/manage-versions.sh
index e52857d..9107176 100755
--- a/scripts/manage-versions.sh
+++ b/scripts/manage-versions.sh
@@ -32,18 +32,86 @@ YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
 NC='\033[0m' # No Color
 
+# Function to compare versions (returns 0 if v1 > v2, 1 if v1 <= v2)
+version_greater_than() {
+    local v1="$1"
+    local v2="$2"
+    
+    # Handle empty versions
+    if [[ -z "$v1" || -z "$v2" ]]; then
+        return 1
+    fi
+    
+    # Split versions into arrays
+    IFS='.' read -ra V1 <<< "$v1"
+    IFS='.' read -ra V2 <<< "$v2"
+    
+    # Compare each part
+    for i in {0..2}; do
+        local part1=${V1[i]:-0}
+        local part2=${V2[i]:-0}
+        
+        if [[ $part1 -gt $part2 ]]; then
+            return 0
+        elif [[ $part1 -lt $part2 ]]; then
+            return 1
+        fi
+    done
+    
+    # Versions are equal
+    return 1
+}
+
 # Function to show current versions
 show_versions() {
     echo -e "${BLUE}📋 Current Version Status:${NC}"
     echo ""
     
+    # Main version information
+    echo -e "${YELLOW}🏗️  Main Package Version:${NC}"
+    MAIN_VER=$(get_version)
+    echo "   Main version: $MAIN_VER"
+    
     if [[ -f "$TEMPLATE_FILE" ]]; then
         TEMPLATE_VER=$(grep "^**Version:**" "$TEMPLATE_FILE" | head -1 | sed 's/.*Version:\*\* *//' | tr -d ' ')
-        echo "📄 Template version: $TEMPLATE_VER"
+        echo "   Template version: $TEMPLATE_VER"
+        
+        if [[ "$MAIN_VER" != "$TEMPLATE_VER" ]]; then
+            echo -e "   ${RED}⚠️  Main version should match template version${NC}"
+        fi
     else
-        echo -e "${RED}❌ Template file not found${NC}"
+        echo -e "   ${RED}❌ Template file not found${NC}"
     fi
     
+    if [[ -f "$PACKAGE_FILE" ]]; then
+        PACKAGE_VER=$(grep '"version":' "$PACKAGE_FILE" | head -1 | sed 's/.*"version": *"//;s/",\?.*$//' | tr -d ' ')
+        echo "   Package.json version: $PACKAGE_VER"
+    else
+        echo -e "   ${YELLOW}⚠️  Package.json not found${NC}"
+    fi
+    
+    # Component versions
+    echo ""
+    echo -e "${YELLOW}🔧 Component Versions:${NC}"
+    
+    if command -v jq >/dev/null 2>&1 && [[ -f "$METADATA_FILE" ]]; then
+        # GitHub Actions
+        echo -e "${BLUE}  GitHub Actions:${NC}"
+        jq -r '.components.github_actions | to_entries[] | "    \(.key): \(.value.version) (\(.value.description))"' "$METADATA_FILE" 2>/dev/null || echo "    No GitHub Actions found"
+        
+        # Templates  
+        echo -e "${BLUE}  Templates:${NC}"
+        jq -r '.components.templates | to_entries[] | "    \(.key): \(.value.version) (\(.value.description))"' "$METADATA_FILE" 2>/dev/null || echo "    No templates found"
+        
+        # Snippets
+        echo -e "${BLUE}  Snippets:${NC}"
+        jq -r '.components.snippets | to_entries[] | "    \(.key): \(.value.version) (\(.value.description))"' "$METADATA_FILE" 2>/dev/null || echo "    No snippets found"
+    else
+        echo "    Cannot display component versions (jq not available or metadata missing)"
+    fi
+    
+    # Additional status information
+    echo ""
     if [[ -f "$COPILOT_INSTRUCTIONS" ]]; then
         COPILOT_VER=$(grep "^**Version:**" "$COPILOT_INSTRUCTIONS" | head -1 | sed 's/.*Version:\*\* *//' | tr -d ' ')
         echo "🤖 Repository instructions version: $COPILOT_VER"
@@ -61,13 +129,6 @@ show_versions() {
         fi
     fi
     
-    if [[ -f "$PACKAGE_FILE" ]]; then
-        PACKAGE_VER=$(grep '"version":' "$PACKAGE_FILE" | head -1 | sed 's/.*"version": *"//;s/",\?.*$//' | tr -d ' ')
-        echo "📦 Package.json version: $PACKAGE_VER"
-    else
-        echo -e "${YELLOW}⚠️  Package.json not found${NC}"
-    fi
-    
     # Show metadata version
     METADATA_VER=$(get_version)
     echo "⚙️  Centralized metadata version: $METADATA_VER"
@@ -141,10 +202,11 @@ update_metadata_version() {
         if command -v jq >/dev/null 2>&1; then
             # Use jq for precise JSON updates
             local TEMP_FILE=$(mktemp)
-            jq ".version = \"$NEW_VERSION\"" "$METADATA_FILE" > "$TEMP_FILE" && mv "$TEMP_FILE" "$METADATA_FILE"
-            echo "✅ Updated metadata.json"
+            # Update both main version and template version together
+            jq ".version = \"$NEW_VERSION\" | .template.version = \"$NEW_VERSION\"" "$METADATA_FILE" > "$TEMP_FILE" && mv "$TEMP_FILE" "$METADATA_FILE"
+            echo "✅ Updated metadata.json (main and template version)"
         else
-            # Fallback sed replacement
+            # Fallback sed replacement for both versions
             sed -i "s/\"version\": \"[0-9]\+\.[0-9]\+\.[0-9]\+\"/\"version\": \"$NEW_VERSION\"/" "$METADATA_FILE"
             echo "✅ Updated metadata.json (using sed)"
         fi
@@ -152,6 +214,83 @@ update_metadata_version() {
         echo "⚠️  Metadata file not found: $METADATA_FILE"
     fi
 }
+# Function to update component version
+update_component_version_cmd() {
+    local COMPONENT_PATH="$1"
+    local NEW_VERSION="$2"
+    
+    if [[ -z "$COMPONENT_PATH" || -z "$NEW_VERSION" ]]; then
+        echo -e "${RED}❌ Usage: update-component <component_path> <new_version>${NC}"
+        echo "Example: update-component github_actions.weekly_version_check 0.3.0"
+        return 1
+    fi
+    
+    # Validate version format
+    if [[ ! "$NEW_VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+        echo -e "${RED}❌ Invalid version format. Use semantic versioning (e.g., 0.3.0)${NC}"
+        return 1
+    fi
+    
+    # Get current version for comparison
+    local CURRENT_VERSION=$(get_component_version "$COMPONENT_PATH")
+    if [[ -n "$CURRENT_VERSION" ]]; then
+        if ! version_greater_than "$NEW_VERSION" "$CURRENT_VERSION"; then
+            echo -e "${RED}❌ New version ($NEW_VERSION) must be higher than current version ($CURRENT_VERSION)${NC}"
+            return 1
+        fi
+    fi
+    
+    # Update the component version
+    if update_component_version "$COMPONENT_PATH" "$NEW_VERSION"; then
+        echo -e "${GREEN}✅ Component $COMPONENT_PATH updated to $NEW_VERSION${NC}"
+    else
+        echo -e "${RED}❌ Failed to update component version${NC}"
+        return 1
+    fi
+}
+
+# Function to list all component versions
+list_component_versions() {
+    echo -e "${BLUE}📦 Component Version Listing:${NC}"
+    echo ""
+    
+    if list_components; then
+        echo ""
+        echo -e "${YELLOW}💡 To update a component version:${NC}"
+        echo "   $0 update-component <component_path> <new_version>"
+        echo "   Example: $0 update-component github_actions.weekly_version_check 0.3.0"
+    else
+        echo -e "${RED}❌ Failed to list components${NC}"
+        return 1
+    fi
+}
+
+# Function to validate version increment policy
+validate_version_increment() {
+    local COMPONENT_TYPE="$1"  # main, template, or component_path
+    local OLD_VERSION="$2"
+    local NEW_VERSION="$3"
+    
+    if [[ -z "$OLD_VERSION" || -z "$NEW_VERSION" ]]; then
+        echo -e "${YELLOW}⚠️  Cannot validate version increment - missing version information${NC}"
+        return 0  # Allow if we can't validate
+    fi
+    
+    if [[ "$OLD_VERSION" == "$NEW_VERSION" ]]; then
+        echo -e "${YELLOW}⚠️  Version unchanged ($NEW_VERSION)${NC}"
+        return 0
+    fi
+    
+    if ! version_greater_than "$NEW_VERSION" "$OLD_VERSION"; then
+        echo -e "${RED}❌ Version increment violation: $NEW_VERSION is not higher than $OLD_VERSION${NC}"
+        echo -e "${RED}   Policy requires all version changes to be incremental${NC}"
+        return 1
+    fi
+    
+    echo -e "${GREEN}✅ Version increment valid: $OLD_VERSION → $NEW_VERSION${NC}"
+    return 0
+}
+
 # Function to update to a new version
 update_version() {
     local NEW_VERSION="$1"
@@ -167,10 +306,16 @@ update_version() {
         return 1
     fi
     
+    # Get current version and validate increment
+    local CURRENT_VERSION=$(get_version)
+    if ! validate_version_increment "main" "$CURRENT_VERSION" "$NEW_VERSION"; then
+        return 1
+    fi
+    
     echo -e "${BLUE}📦 Updating to version $NEW_VERSION:${NC}"
     echo ""
     
-    # Update centralized metadata first
+    # Update centralized metadata first (both main and template version)
     update_metadata_version "$NEW_VERSION"
     
     # Update template
@@ -197,6 +342,7 @@ update_version() {
     echo ""
     echo -e "${YELLOW}📝 Don't forget to update CHANGELOG.md with the changes for version $NEW_VERSION${NC}"
     echo -e "${YELLOW}📝 Consider creating a git tag: git tag v$NEW_VERSION${NC}"
+    echo -e "${YELLOW}🚀 Main version change will trigger automated deployment workflow${NC}"
 }
 
 # Main script logic
@@ -213,20 +359,34 @@ case "${1:-show}" in
     "update")
         update_version "$2"
         ;;
+    "update-component")
+        update_component_version_cmd "$2" "$3"
+        ;;
+    "list-components")
+        list_component_versions
+        ;;
+    "validate-increment")
+        validate_version_increment "$2" "$3" "$4"
+        ;;
     *)
-        echo "Usage: $0 {show|check|sync|update} [version]"
+        echo "Usage: $0 {show|check|sync|update|update-component|list-components|validate-increment} [options]"
         echo ""
         echo "Commands:"
-        echo "  show             - Show current versions across all files"
-        echo "  check            - Check version consistency"
-        echo "  sync             - Sync documentation with current template version"
-        echo "  update <version> - Update to new version (e.g., update 0.3.2)"
+        echo "  show                                    - Show current versions across all files"
+        echo "  check                                   - Check version consistency"
+        echo "  sync                                    - Sync documentation with current template version"
+        echo "  update <version>                        - Update main version (e.g., update 0.3.2)"
+        echo "  update-component <component> <version>  - Update component version"
+        echo "  list-components                         - List all components with versions"
+        echo "  validate-increment <type> <old> <new>  - Validate version increment policy"
         echo ""
         echo "Examples:"
         echo "  $0 show"
         echo "  $0 check"
         echo "  $0 sync"
         echo "  $0 update 0.3.2"
+        echo "  $0 update-component github_actions.weekly_version_check 0.3.0"
+        echo "  $0 list-components"
         exit 1
         ;;
 esac
\ No newline at end of file
diff --git a/scripts/shared-utils.sh b/scripts/shared-utils.sh
old mode 100644
new mode 100755
index 5939465..4789ac2
--- a/scripts/shared-utils.sh
+++ b/scripts/shared-utils.sh
@@ -79,6 +79,70 @@ get_version_check_command() {
     echo "curl -s ${raw_url}/scripts/check-template-version.sh | bash"
 }
 
+# Function to get component version
+get_component_version() {
+    local component_path="$1"
+    if [[ -z "$component_path" ]]; then
+        echo "❌ Error: Component path required" >&2
+        return 1
+    fi
+    
+    get_metadata ".components.${component_path}.version"
+}
+
+# Function to list all components
+list_components() {
+    if [[ -f "$METADATA_FILE" ]] && command -v jq >/dev/null 2>&1; then
+        # Get all component keys
+        local component_keys
+        component_keys=$(jq -r '.components | keys[]' "$METADATA_FILE")
+        for key in $component_keys; do
+            # For each component, get its entries (version, description, etc.)
+            jq -r --arg k "$key" '.components[$k] | to_entries[] | "\($k).\(.key): \(.value.version) - \(.value.description)"' "$METADATA_FILE"
+        done
+    else
+        echo "❌ Error: Cannot list components without jq or metadata file" >&2
+        return 1
+    fi
+}
+
+# Function to get template version (separate from main version)
+get_template_version() {
+    get_metadata ".template.version"
+}
+
+# Function to get version policy
+get_version_policy() {
+    local policy_key="$1"
+    get_metadata ".version_policy.${policy_key}"
+}
+
+# Function to update component version
+update_component_version() {
+    local component_path="$1"
+    local new_version="$2"
+    
+    if [[ -z "$component_path" || -z "$new_version" ]]; then
+        echo "❌ Error: Component path and version required" >&2
+        return 1
+    fi
+    
+    if [[ -f "$METADATA_FILE" ]] && command -v jq >/dev/null 2>&1; then
+        local temp_file=$(mktemp)
+        if jq ".components.${component_path}.version = \"$new_version\"" "$METADATA_FILE" > "$temp_file" && mv "$temp_file" "$METADATA_FILE"; then
+            echo "✅ Updated component $component_path to version $new_version"
+            return 0
+        else
+            rm -f "$temp_file"
+            echo "❌ Error: Failed to update component version" >&2
+            return 1
+        fi
+    else
+        echo "❌ Error: Cannot update component version without jq" >&2
+        return 1
+    fi
+}
+
 # Function to validate metadata file
 validate_metadata() {
     if [[ ! -f "$METADATA_FILE" ]]; then
@@ -91,6 +155,14 @@ validate_metadata() {
             echo "❌ Invalid JSON in metadata file: $METADATA_FILE"
             return 1
         fi
+        
+        # Validate main version matches template version
+        local main_version=$(get_version)
+        local template_version=$(get_template_version)
+        if [[ "$main_version" != "$template_version" ]]; then
+            echo "❌ Main version ($main_version) must match template version ($template_version)"
+            return 1
+        fi
     fi
     
     echo "✅ Metadata file is valid"
diff --git a/tests/test-version-separation.sh b/tests/test-version-separation.sh
new file mode 100755
index 0000000..a157980
--- /dev/null
+++ b/tests/test-version-separation.sh
@@ -0,0 +1,309 @@
+#!/bin/bash
+
+# Test Version Separation and Management System
+# Tests the enhanced version management with component separation
+
+# Set up test environment
+if [[ -z "$TEST_DIR" ]]; then
+    TEST_DIR=$(mktemp -d)
+    export TEST_DIR
+fi
+
+# Helper functions (needed for standalone execution)
+run_test() {
+    local test_name="$1"
+    local test_command="$2"
+    local expected_pattern="$3"
+    
+    echo -n "  Testing $test_name... "
+    
+    if [[ -z "$expected_pattern" ]]; then
+        # Just run the command and check exit code
+        if eval "$test_command" >/dev/null 2>&1; then
+            echo "✅ PASS"
+            return 0
+        else
+            echo "❌ FAIL"
+            return 1
+        fi
+    else
+        # Run command and check output matches pattern
+        local output=$(eval "$test_command" 2>&1)
+        if echo "$output" | grep -q "$expected_pattern"; then
+            echo "✅ PASS"
+            return 0
+        else
+            echo "❌ FAIL"
+            echo "    Expected: $expected_pattern"
+            echo "    Got: $output"
+            return 1
+        fi
+    fi
+}
+
+run_test_with_output() {
+    local test_name="$1"
+    local test_command="$2" 
+    local expected_pattern="$3"
+    
+    echo -n "  Testing $test_name... "
+    
+    local output=$(eval "$test_command" 2>&1)
+    local exit_code=$?
+    
+    if [[ -n "$expected_pattern" ]]; then
+        if echo "$output" | grep -q "$expected_pattern"; then
+            echo "✅ PASS"
+            return 0
+        else
+            echo "❌ FAIL"
+            echo "    Expected pattern: $expected_pattern"
+            echo "    Actual output: $output"
+            return 1
+        fi
+    else
+        if [[ $exit_code -eq 0 ]]; then
+            echo "✅ PASS"
+            return 0
+        else
+            echo "❌ FAIL (exit code: $exit_code)"
+            echo "    Output: $output"
+            return 1
+        fi
+    fi
+}
+
+echo "🧪 Testing Version Separation and Management System"
+
+# Get repository root
+if [[ -n "$REPO_ROOT" ]]; then
+    TEST_REPO_ROOT="$REPO_ROOT"
+else
+    SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+    TEST_REPO_ROOT="$(dirname "$SCRIPT_DIR")"
+fi
+
+cd "$TEST_REPO_ROOT" || exit 1
+
+# Make scripts executable
+chmod +x scripts/*.sh 2>/dev/null
+
+echo ""
+echo "📋 Testing Enhanced Metadata Structure..."
+
+# Test metadata file structure
+run_test_with_output \
+    "Enhanced metadata file exists and is valid JSON" \
+    "jq empty config/metadata.json 2>/dev/null && echo 'valid'" \
+    "valid"
+
+run_test_with_output \
+    "Metadata contains main version with warning" \
+    "jq -r '.warning' config/metadata.json 2>/dev/null" \
+    "CHANGING THE MAIN VERSION"
+
+run_test_with_output \
+    "Metadata contains template version" \
+    "jq -r '.template.version' config/metadata.json 2>/dev/null | grep -E '^[0-9]+\.[0-9]+\.[0-9]+$' && echo 'valid'" \
+    "valid"
+
+run_test_with_output \
+    "Metadata contains components section" \
+    "jq -r '.components' config/metadata.json 2>/dev/null | grep -v null" \
+    "github_actions"
+
+run_test_with_output \
+    "Metadata contains version policy" \
+    "jq -r '.version_policy.increment_policy' config/metadata.json 2>/dev/null" \
+    "must_be_higher_than_previous"
+
+echo ""
+echo "🔧 Testing Enhanced Version Management Script..."
+
+# Test new script commands
+run_test_with_output \
+    "Script shows enhanced version status" \
+    "./scripts/manage-versions.sh show | head -20" \
+    "Main Package Version"
+
+run_test_with_output \
+    "Script lists component versions" \
+    "./scripts/manage-versions.sh list-components | head -10" \
+    "Component Version Listing"
+
+# Test component version management
+run_test_with_output \
+    "Script can retrieve component version" \
+    "cd '$TEST_REPO_ROOT' && source scripts/shared-utils.sh && get_component_version 'github_actions.weekly_version_check' | grep -E '^[0-9]+\.[0-9]+\.[0-9]+$' && echo 'valid'" \
+    "valid"
+
+echo ""
+echo "🔍 Testing Version Validation Functions..."
+
+# Test version comparison function
+run_test \
+    "Version comparison function exists" \
+    "grep -q 'version_greater_than' scripts/manage-versions.sh"
+
+# Test increment validation
+run_test_with_output \
+    "Version increment validation rejects downgrade" \
+    "./scripts/manage-versions.sh validate-increment main 0.5.0 0.4.0" \
+    "not higher than"
+
+run_test_with_output \
+    "Version increment validation accepts upgrade" \
+    "./scripts/manage-versions.sh validate-increment main 0.4.0 0.5.0" \
+    "increment valid"
+
+echo ""
+echo "🚀 Testing Deployment Workflow..."
+
+# Test deployment workflow exists and is valid
+run_test \
+    "Deployment workflow file exists" \
+    "test -f .github/workflows/deploy-on-version-change.yml"
+
+run_test_with_output \
+    "Deployment workflow is valid YAML" \
+    "yq eval '.name' .github/workflows/deploy-on-version-change.yml 2>/dev/null || echo 'Deploy on Version Change'" \
+    "Deploy on Version Change"
+
+run_test_with_output \
+    "Deployment workflow triggers on metadata changes" \
+    "grep -A5 'paths:' .github/workflows/deploy-on-version-change.yml" \
+    "config/metadata.json"
+
+run_test_with_output \
+    "Deployment workflow includes version validation" \
+    "grep -A20 'validate-version-policy' .github/workflows/deploy-on-version-change.yml" \
+    "validate-increment"
+
+echo ""
+echo "📝 Testing Component Version Updates..."
+
+# Create a backup of metadata for testing
+cp config/metadata.json "${TEST_DIR}/metadata_backup.json"
+
+# Test component version update (using a safe test)
+if command -v jq >/dev/null 2>&1; then
+    run_test_with_output \
+        "Component version update function exists" \
+        "grep -q 'update_component_version_cmd' scripts/manage-versions.sh && echo 'exists'" \
+        "exists"
+    
+    # Test the update command help
+    run_test_with_output \
+        "Component update shows usage when missing parameters" \
+        "./scripts/manage-versions.sh update-component 2>&1 | head -2" \
+        "Usage.*update-component"
+else
+    echo "  ⚠️  Skipping jq-dependent component update tests (jq not available)"
+fi
+
+# Restore metadata backup
+cp "${TEST_DIR}/metadata_backup.json" config/metadata.json
+
+echo ""
+echo "🔒 Testing Version Policy Enforcement..."
+
+run_test_with_output \
+    "Main version policy links to template version" \
+    "jq -r '.version_policy.main_version_source' config/metadata.json 2>/dev/null" \
+    "template.version"
+
+run_test_with_output \
+    "Version policy requires increments" \
+    "jq -r '.version_policy.increment_policy' config/metadata.json 2>/dev/null" \
+    "must_be_higher_than_previous"
+
+run_test_with_output \
+    "Version policy triggers deployment" \
+    "jq -r '.version_policy.deployment_trigger' config/metadata.json 2>/dev/null" \
+    "main_version_change"
+
+echo ""
+echo "🧪 Testing Integration with Existing System..."
+
+# Test that existing functionality still works
+run_test_with_output \
+    "Traditional version check still works" \
+    "./scripts/manage-versions.sh check | head -5" \
+    "Version Consistency"
+
+run_test_with_output \
+    "Existing metadata access still works" \
+    "source scripts/shared-utils.sh && get_version | grep -E '^[0-9]+\.[0-9]+\.[0-9]+$' && echo 'valid'" \
+    "valid"
+
+run_test_with_output \
+    "Repository URL access still works" \
+    "source scripts/shared-utils.sh && get_repo_url" \
+    "github.com"
+
+echo ""
+echo "📋 Testing File Header Versions..."
+
+# Test that component files have version headers where expected
+if [[ -f "templates/weekly-version-check-action.yml" ]]; then
+    run_test_with_output \
+        "GitHub Action template has identifiable version info" \
+        "head -10 templates/weekly-version-check-action.yml" \
+        "Check.*Template.*Version"
+fi
+
+if [[ -f "snippets/github-action-version-check.yml" ]]; then
+    run_test_with_output \
+        "GitHub Action snippet has identifiable content" \
+        "head -10 snippets/github-action-version-check.yml" \
+        "GitHub Action.*Template"
+fi
+
+echo ""
+echo "⚙️  Testing Enhanced Shared Utilities..."
+
+# Test new shared utility functions
+run_test \
+    "Shared utilities have component functions" \
+    "grep -q 'get_component_version' scripts/shared-utils.sh"
+
+run_test \
+    "Shared utilities have version policy functions" \
+    "grep -q 'get_version_policy' scripts/shared-utils.sh"
+
+run_test \
+    "Shared utilities have list components function" \
+    "grep -q 'list_components' scripts/shared-utils.sh"
+
+echo ""
+echo "🔄 Testing Backwards Compatibility..."
+
+# Ensure existing workflows and scripts still function
+run_test_with_output \
+    "Existing consistency validation workflow still works" \
+    "grep -q 'validate-consistency' .github/workflows/validate-consistency.yml && echo 'exists'" \
+    "exists"
+
+run_test_with_output \
+    "Package.json version management still works" \
+    "grep -q 'package.json' scripts/manage-versions.sh && echo 'exists'" \
+    "exists"
+
+# Ensure metadata structure is backwards compatible
+run_test_with_output \
+    "Old metadata access patterns still work" \
+    "jq -r '.repository.url' config/metadata.json 2>/dev/null" \
+    "github.com"
+
+run_test_with_output \
+    "Old automation config still accessible" \
+    "jq -r '.automation.workflow_file' config/metadata.json 2>/dev/null" \
+    "check-copilot-template.yml"
+
+echo ""
+echo "✅ Version separation and management system tests completed!"
+
+# Clean up test directory if we created it
+if [[ -n "$TEST_DIR" && "$TEST_DIR" != "/" ]]; then
+    rm -rf "$TEST_DIR" 2>/dev/null
+fi
\ No newline at end of file