aios-core 4.0.2 → 4.0.4

package/.claude/hooks/enforce-architecture-first.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""
+Hook: Enforce Architecture-First Development
+
+REGRA: Código só pode ser criado/editado se existir documentação prévia.
+
+Este hook intercepta Write/Edit em paths de código e verifica se existe
+documentação aprovada antes de permitir a operação.
+
+Exit Codes:
+- 0: Permitido (doc existe ou path não requer doc)
+- 2: Bloqueado (doc não existe para path protegido)
+"""
+
+import json
+import sys
+import os
+from pathlib import Path
+
+# =============================================================================
+# CONFIGURAÇÃO: Paths que EXIGEM documentação prévia
+# =============================================================================
+
+PROTECTED_PATHS = [
+    # Edge Functions - exigem docs/architecture/{function-name}.md
+    {
+        "pattern": "supabase/functions/",
+        "doc_patterns": [
+            "docs/architecture/{name}.md",
+            "docs/architecture/{name}-architecture.md",
+            "docs/approved-plans/{name}.md",
+        ],
+        "extract_name": lambda p: p.split("supabase/functions/")[1].split("/")[0] if "supabase/functions/" in p else None,
+    },
+    # Migrations - exigem documentação de schema changes
+    {
+        "pattern": "supabase/migrations/",
+        "doc_patterns": [
+            "docs/approved-plans/migration-{name}.md",
+            "docs/architecture/database-changes.md",
+        ],
+        "extract_name": lambda p: Path(p).stem if "supabase/migrations/" in p else None,
+        "allow_if_exists": True,  # Permite editar migrations existentes
+    },
+]
+
+# Paths que são SEMPRE permitidos (não exigem doc)
+ALWAYS_ALLOWED = [
+    ".claude/",
+    "docs/",
+    "outputs/",
+    "squads/",
+    ".aios-core/",
+    ".aios-custom/",
+    "node_modules/",
+    ".git/",
+    "package.json",
+    "package-lock.json",
+    "tsconfig.json",
+    ".env",
+    "README.md",
+]
+
+# =============================================================================
+# LÓGICA DO HOOK
+# =============================================================================
+
+def get_project_root():
+    """Obtém o root do projeto via variável de ambiente ou cwd."""
+    return os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+
+def is_always_allowed(file_path: str) -> bool:
+    """Verifica se o path está na lista de sempre permitidos."""
+    for allowed in ALWAYS_ALLOWED:
+        if allowed in file_path:
+            return True
+    return False
+
+def find_matching_protection(file_path: str) -> dict | None:
+    """Encontra a regra de proteção que corresponde ao path."""
+    for protection in PROTECTED_PATHS:
+        if protection["pattern"] in file_path:
+            return protection
+    return None
+
+def check_documentation_exists(file_path: str, protection: dict, project_root: str) -> tuple[bool, str]:
+    """
+    Verifica se existe documentação para o path protegido.
+
+    Returns:
+        (exists: bool, doc_path: str | None)
+    """
+    extract_fn = protection.get("extract_name")
+    if not extract_fn:
+        return True, None
+
+    name = extract_fn(file_path)
+    if not name:
+        return True, None
+
+    # Verificar cada padrão de documentação
+    for doc_pattern in protection["doc_patterns"]:
+        doc_path = doc_pattern.format(name=name)
+        full_doc_path = os.path.join(project_root, doc_path)
+
+        if os.path.exists(full_doc_path):
+            return True, doc_path
+
+    # Se allow_if_exists e o arquivo já existe, permitir edição
+    if protection.get("allow_if_exists"):
+        full_file_path = os.path.join(project_root, file_path) if not file_path.startswith("/") else file_path
+        if os.path.exists(full_file_path):
+            return True, "(arquivo existente)"
+
+    return False, None
+
+def format_required_docs(protection: dict, name: str) -> str:
+    """Formata a lista de documentos aceitos."""
+    docs = []
+    for pattern in protection["doc_patterns"]:
+        docs.append(f"  - {pattern.format(name=name)}")
+    return "\n".join(docs)
+
+def main():
+    # Ler input do stdin
+    try:
+        input_data = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        # Se não conseguir parsear, permitir (fail-open)
+        sys.exit(0)
+
+    tool_name = input_data.get("tool_name", "")
+    tool_input = input_data.get("tool_input", {})
+    file_path = tool_input.get("file_path", "")
+
+    # Só processar Write e Edit
+    if tool_name not in ["Write", "Edit"]:
+        sys.exit(0)
+
+    # Normalizar path (remover prefixo absoluto se presente)
+    project_root = get_project_root()
+    relative_path = file_path
+    if file_path.startswith(project_root):
+        relative_path = file_path[len(project_root):].lstrip("/")
+
+    # Verificar se é sempre permitido
+    if is_always_allowed(relative_path):
+        sys.exit(0)
+
+    # Verificar se path está protegido
+    protection = find_matching_protection(relative_path)
+    if not protection:
+        # Path não protegido, permitir
+        sys.exit(0)
+
+    # Verificar se documentação existe
+    doc_exists, doc_path = check_documentation_exists(relative_path, protection, project_root)
+
+    if doc_exists:
+        # Documentação existe, permitir
+        sys.exit(0)
+
+    # BLOQUEAR: Documentação não existe
+    name = protection["extract_name"](relative_path) or "unknown"
+    required_docs = format_required_docs(protection, name)
+
+    error_message = f"""
+╔══════════════════════════════════════════════════════════════════════════════╗
+║  🛑 ARCHITECTURE-FIRST: Documentação obrigatória antes de código             ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                                                                              ║
+║  Arquivo bloqueado: {relative_path[:50]:<50} ║
+║                                                                              ║
+║  REGRA: Antes de criar/editar código em paths protegidos, você DEVE:         ║
+║                                                                              ║
+║  1. Documentar o plano de arquitetura                                        ║
+║  2. Obter aprovação do usuário                                               ║
+║  3. Criar o arquivo de documentação                                          ║
+║                                                                              ║
+║  Documentos aceitos para '{name}':                                           ║
+{required_docs}
+║                                                                              ║
+║  AÇÃO: Crie um dos documentos acima com o plano aprovado, depois tente       ║
+║        novamente a operação de código.                                       ║
+║                                                                              ║
+║  DICA: Use `*create-doc architecture` para criar doc de arquitetura          ║
+║        Ou crie docs/approved-plans/{name}.md com o plano resumido             ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+"""
+
+    print(error_message, file=sys.stderr)
+    sys.exit(2)  # Exit code 2 = bloqueia o tool
+
+if __name__ == "__main__":
+    main()

package/.claude/hooks/install-hooks.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+# Install AIOS Git Hooks
+# Version: 1.0
+
+set -e
+
+echo "🔧 Installing AIOS Git Hooks..."
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+HOOKS_DIR="$PROJECT_ROOT/.git/hooks"
+
+# Ensure hooks directory exists
+if [ ! -d "$HOOKS_DIR" ]; then
+    echo "❌ Error: .git/hooks directory not found"
+    echo "Are you in a git repository?"
+    exit 1
+fi
+
+# Install pre-commit hook (MMOS architecture guard)
+echo "Installing pre-commit hook (MMOS architecture guard)..."
+ln -sf ../../.aios-core/hooks/pre-commit-mmos-guard.sh "$HOOKS_DIR/pre-commit"
+chmod +x "$HOOKS_DIR/pre-commit"
+
+echo "✅ Pre-commit hook installed"
+
+# Make all hooks executable
+chmod +x "$SCRIPT_DIR"/*.sh
+
+echo ""
+echo "✅ All hooks installed successfully!"
+echo ""
+echo "Installed hooks:"
+echo "  - pre-commit: MMOS architecture guard"
+echo ""
+echo "To test:"
+echo "  .aios-core/hooks/pre-commit-mmos-guard.sh"
+echo ""
+echo "To uninstall:"
+echo "  rm .git/hooks/pre-commit"

package/.claude/hooks/mind-clone-governance.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""
+Hook: Mind Clone Governance
+
+REGRA: Agents baseados em pessoas reais (mind clones) DEVEM passar pelo
+pipeline de extração de DNA antes de serem criados.
+
+Este hook intercepta Write/Edit em squads/*/agents/*.md e verifica:
+1. Se é um mind clone (baseado em pessoa real)
+2. Se existe DNA extraído correspondente
+
+NÃO BLOQUEIA:
+- Orchestrators (nome contém 'chief', 'orchestrator', 'chair')
+- Tool agents (nome contém 'validator', 'calculator', 'generator')
+- Process agents (nome contém 'architect', 'mapper', 'designer')
+- Edição de arquivo existente (apenas criação é bloqueada)
+
+Exit Codes:
+- 0: Permitido
+- 2: Bloqueado (mind clone sem DNA)
+"""
+
+import json
+import sys
+import os
+import re
+from pathlib import Path
+
+# =============================================================================
+# CONFIGURAÇÃO
+# =============================================================================
+
+# Padrões que indicam que NÃO é um mind clone (agents funcionais)
+FUNCTIONAL_AGENT_PATTERNS = [
+    # Orchestrators
+    r'.*-chief$',
+    r'.*-orchestrator$',
+    r'.*-chair$',
+    r'^orchestrator$',
+
+    # Tool agents
+    r'.*-validator$',
+    r'.*-calculator$',
+    r'.*-generator$',
+    r'.*-extractor$',
+    r'.*-analyzer$',
+
+    # Process agents
+    r'.*-architect$',
+    r'.*-mapper$',
+    r'.*-designer$',
+    r'.*-engineer$',
+
+    # Generic functional
+    r'^tools?-.*',
+    r'^process-.*',
+    r'^workflow-.*',
+]
+
+# Locais onde DNA pode estar
+DNA_LOCATIONS = [
+    "squads/{pack}/data/minds/{agent_id}_dna.yaml",
+    "squads/{pack}/data/minds/{agent_id}_dna.md",
+    "squads/{pack}/data/{agent_id}-dna.yaml",
+    "outputs/minds/{agent_id}/",
+]
+
+# =============================================================================
+# LÓGICA DO HOOK
+# =============================================================================
+
+def get_project_root():
+    """Obtém o root do projeto via variável de ambiente ou cwd."""
+    return os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+
+def extract_agent_info(file_path: str) -> tuple:
+    """Extrai pack_name e agent_id do path."""
+    # squads/{pack}/agents/{agent_id}.md
+    match = re.match(r'.*/squads/([^/]+)/agents/([^/]+)\.md$', file_path)
+    if match:
+        return match.group(1), match.group(2)
+    return None, None
+
+def is_functional_agent(agent_id: str) -> bool:
+    """Verifica se o agent é funcional (não é mind clone)."""
+    for pattern in FUNCTIONAL_AGENT_PATTERNS:
+        if re.match(pattern, agent_id, re.IGNORECASE):
+            return True
+    return False
+
+def has_dna_extracted(project_root: str, pack_name: str, agent_id: str) -> tuple:
+    """Verifica se existe DNA extraído para o agent."""
+    for location_template in DNA_LOCATIONS:
+        location = location_template.format(pack=pack_name, agent_id=agent_id)
+        full_path = os.path.join(project_root, location)
+
+        # Se é diretório, verificar se existe
+        if location.endswith('/'):
+            if os.path.isdir(full_path):
+                return True, full_path
+        # Se é arquivo, verificar se existe
+        elif os.path.isfile(full_path):
+            return True, full_path
+
+    return False, None
+
+def file_already_exists(file_path: str) -> bool:
+    """Verifica se o arquivo já existe (edit vs create)."""
+    return os.path.isfile(file_path)
+
+def main():
+    # Ler input do stdin
+    try:
+        input_data = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        # Se não conseguir parsear, permitir (fail-open)
+        sys.exit(0)
+
+    tool_name = input_data.get("tool_name", "")
+    tool_input = input_data.get("tool_input", {})
+
+    # Só processar Write e Edit
+    if tool_name not in ["Write", "Edit"]:
+        sys.exit(0)
+
+    file_path = tool_input.get("file_path", "")
+    if not file_path:
+        sys.exit(0)
+
+    # Só processar arquivos em squads/*/agents/
+    if "/squads/" not in file_path or "/agents/" not in file_path:
+        sys.exit(0)
+
+    if not file_path.endswith(".md"):
+        sys.exit(0)
+
+    project_root = get_project_root()
+
+    # Extrair informações do path
+    pack_name, agent_id = extract_agent_info(file_path)
+    if not pack_name or not agent_id:
+        sys.exit(0)
+
+    # Se é edição de arquivo existente, permitir
+    if file_already_exists(file_path):
+        sys.exit(0)
+
+    # Se é agent funcional (não mind clone), permitir
+    if is_functional_agent(agent_id):
+        sys.exit(0)
+
+    # Verificar se existe DNA extraído
+    has_dna, dna_path = has_dna_extracted(project_root, pack_name, agent_id)
+
+    if has_dna:
+        sys.exit(0)
+
+    # BLOQUEAR: Tentando criar mind clone sem DNA
+    error_message = f"""
+╔══════════════════════════════════════════════════════════════════════════════╗
+║  🧬 MIND CLONE GOVERNANCE: DNA não encontrado                                 ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                                                                              ║
+║  Agent: {agent_id:<60} ║
+║  Pack:  {pack_name:<60} ║
+║                                                                              ║
+║  PROBLEMA: Este parece ser um MIND CLONE (baseado em pessoa real),           ║
+║            mas não foi encontrado DNA extraído.                              ║
+║                                                                              ║
+║  Mind clones DEVEM passar pelo pipeline de extração:                         ║
+║  1. *collect-sources  → Coletar fontes (livros, entrevistas, artigos)        ║
+║  2. *extract-voice-dna → Extrair padrões linguísticos                        ║
+║  3. *extract-thinking-dna → Extrair frameworks e heurísticas                 ║
+║  4. *create-agent → Criar agent a partir do DNA                              ║
+║                                                                              ║
+║  LOCAIS VERIFICADOS:                                                         ║
+║  • squads/{pack_name}/data/minds/{agent_id}_dna.yaml
+║  • squads/{pack_name}/data/minds/{agent_id}_dna.md
+║  • outputs/minds/{agent_id}/
+║                                                                              ║
+║  SOLUÇÕES:                                                                   ║
+║  1. Execute o pipeline de clone: /squad-creator → *collect-sources           ║
+║  2. OU se é agent FUNCIONAL, renomeie com sufixo:                            ║
+║     -chief, -orchestrator, -validator, -architect, etc.                      ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+"""
+    print(error_message, file=sys.stderr)
+    sys.exit(2)
+
+if __name__ == "__main__":
+    main()

package/.claude/hooks/pre-commit-mmos-guard.sh

@@ -0,0 +1,99 @@
+#!/bin/bash
+# MMOS Architecture Guard - Pre-commit Hook
+# Version: 1.0
+# Purpose: Prevent architectural violations in file placement
+
+set -e
+
+echo "🛡️  Running MMOS Architecture Guard..."
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+violations=0
+
+# Get staged files
+staged_files=$(git diff --cached --name-only --diff-filter=ACM)
+
+# Rule 1: No mind-specific folders in docs/mmos/
+echo "Checking Rule 1: No mind-specific folders in docs/mmos/..."
+
+if echo "$staged_files" | grep -qE "docs/mmos/(validations|migrations)/[a-z_-]+"; then
+    echo -e "${RED}❌ VIOLATION: Mind-specific folders detected in docs/mmos/${NC}"
+    echo ""
+    echo "Found:"
+    echo "$staged_files" | grep -E "docs/mmos/(validations|migrations)/[a-z_-]+" | sed 's/^/  - /'
+    echo ""
+    echo -e "${YELLOW}Fix: Move to outputs/minds/{slug}/docs/ instead${NC}"
+    echo ""
+    echo "Examples:"
+    echo "  ❌ docs/mmos/validations/pedro-valerio-checklist.md"
+    echo "  ✅ outputs/minds/pedro_valerio/docs/validation-checklist.md"
+    echo ""
+    violations=$((violations + 1))
+fi
+
+# Rule 2: No output files in expansion pack
+echo "Checking Rule 2: No output files in expansion pack..."
+
+if echo "$staged_files" | grep -qE "expansion-packs/mmos/(benchmarks|outputs|results)/"; then
+    echo -e "${RED}❌ VIOLATION: Output files in expansion pack${NC}"
+    echo ""
+    echo "Found:"
+    echo "$staged_files" | grep -E "expansion-packs/mmos/(benchmarks|outputs|results)/" | sed 's/^/  - /'
+    echo ""
+    echo -e "${YELLOW}Fix: Move to docs/mmos/qa/benchmarks/ or appropriate output location${NC}"
+    echo ""
+    violations=$((violations + 1))
+fi
+
+# Rule 3: Check for common naming violations
+echo "Checking Rule 3: Mind-specific files should be in outputs/minds/..."
+
+# Check for files with mind names in docs/mmos/ (excluding allowed folders)
+for mind_name in $(ls outputs/minds/ 2>/dev/null | grep -v "^README" || true); do
+    if echo "$staged_files" | grep -qE "docs/mmos/.*${mind_name}"; then
+        # Exclude allowed locations (reports can mention minds)
+        if ! echo "$staged_files" | grep -qE "docs/mmos/(reports|architecture)/"; then
+            echo -e "${YELLOW}⚠️  WARNING: File containing mind name '$mind_name' in docs/mmos/${NC}"
+            echo "$staged_files" | grep -E "docs/mmos/.*${mind_name}" | sed 's/^/  - /'
+            echo ""
+            echo "Verify this is system-level documentation, not mind-specific"
+            echo ""
+        fi
+    fi
+done
+
+# Rule 4: Verify outputs/minds/{slug}/ structure
+echo "Checking Rule 4: outputs/minds/{slug}/ structure..."
+
+if echo "$staged_files" | grep -qE "outputs/minds/[^/]+/[^/]+\.(md|yaml|json)$"; then
+    echo -e "${YELLOW}⚠️  WARNING: Files in outputs/minds/{slug}/ root detected${NC}"
+    echo ""
+    echo "Found:"
+    echo "$staged_files" | grep -E "outputs/minds/[^/]+/[^/]+\.(md|yaml|json)$" | sed 's/^/  - /'
+    echo ""
+    echo "Pipeline outputs should be in subfolders:"
+    echo "  - analysis/, synthesis/, implementation/, system_prompts/, kb/"
+    echo "  - Process docs should be in docs/"
+    echo "  - Logs should be in logs/"
+    echo ""
+fi
+
+# Final verdict
+echo ""
+if [ $violations -gt 0 ]; then
+    echo -e "${RED}❌ COMMIT REJECTED: $violations architectural violation(s) found${NC}"
+    echo ""
+    echo "Review:"
+    echo "  - docs/mmos/ARCHITECTURE_RULES.md"
+    echo "  - .aios-core/checklists/mmos-architecture-guard.md"
+    echo ""
+    exit 1
+else
+    echo -e "${GREEN}✅ Architecture guard passed${NC}"
+    exit 0
+fi

package/.claude/hooks/pre-commit-version-check.sh

@@ -0,0 +1,156 @@
+#!/bin/bash
+#
+# Pre-Commit Hook: Version Metadata Validation
+#
+# Ensures all tasks and agents have version metadata in frontmatter.
+# This prevents silent version mismatches (e.g., v1.0 agent + v2.0 task).
+#
+# Usage:
+#   Run manually: .aios-core/hooks/pre-commit-version-check.sh
+#   Install: .aios-core/hooks/install-hooks.sh
+#
+# Story: STORY-3.10 (Version Alignment & Compatibility Checks)
+
+set -e
+
+echo "🔍 Validating task and agent version metadata..."
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Track validation status
+ERRORS=0
+
+# Function to check if file has required version fields
+check_task_version() {
+    local file="$1"
+    local missing_fields=()
+
+    if ! grep -q "^task_name:" "$file"; then
+        missing_fields+=("task_name")
+    fi
+
+    if ! grep -q "^task_version:" "$file"; then
+        missing_fields+=("task_version")
+    fi
+
+    if ! grep -q "^required_agent_version:" "$file"; then
+        missing_fields+=("required_agent_version")
+    fi
+
+    if ! grep -q "^description:" "$file"; then
+        missing_fields+=("description")
+    fi
+
+    if ! grep -q "^last_updated:" "$file"; then
+        missing_fields+=("last_updated")
+    fi
+
+    if [ ${#missing_fields[@]} -gt 0 ]; then
+        echo -e "${RED}❌ ERROR: $file missing version metadata${NC}"
+        for field in "${missing_fields[@]}"; do
+            echo -e "${RED}   - Missing field: '$field'${NC}"
+        done
+        echo ""
+        ERRORS=$((ERRORS + 1))
+        return 1
+    fi
+
+    return 0
+}
+
+check_agent_version() {
+    local file="$1"
+    local missing_fields=()
+
+    if ! grep -q "^agent_name:" "$file"; then
+        missing_fields+=("agent_name")
+    fi
+
+    if ! grep -q "^agent_version:" "$file"; then
+        missing_fields+=("agent_version")
+    fi
+
+    if ! grep -q "^compatible_task_versions:" "$file"; then
+        missing_fields+=("compatible_task_versions")
+    fi
+
+    if ! grep -q "^description:" "$file"; then
+        missing_fields+=("description")
+    fi
+
+    if ! grep -q "^last_updated:" "$file"; then
+        missing_fields+=("last_updated")
+    fi
+
+    if [ ${#missing_fields[@]} -gt 0 ]; then
+        echo -e "${RED}❌ ERROR: $file missing version metadata${NC}"
+        for field in "${missing_fields[@]}"; do
+            echo -e "${RED}   - Missing field: '$field'${NC}"
+        done
+        echo ""
+        ERRORS=$((ERRORS + 1))
+        return 1
+    fi
+
+    return 0
+}
+
+# Check all tasks in expansion-packs/creator-os/tasks/
+echo "Checking CreatorOS tasks..."
+TASK_COUNT=0
+for task in expansion-packs/creator-os/tasks/*.md; do
+    # Skip backup files
+    if [[ "$task" == *"-backup.md" ]]; then
+        echo -e "${YELLOW}⏭️  Skipping backup: $task${NC}"
+        continue
+    fi
+
+    if [ -f "$task" ]; then
+        if check_task_version "$task"; then
+            echo -e "${GREEN}✅ $task${NC}"
+        fi
+        TASK_COUNT=$((TASK_COUNT + 1))
+    fi
+done
+
+# Check all agents in expansion-packs/creator-os/agents/
+echo ""
+echo "Checking CreatorOS agents..."
+AGENT_COUNT=0
+for agent in expansion-packs/creator-os/agents/*.md; do
+    if [ -f "$agent" ]; then
+        if check_agent_version "$agent"; then
+            echo -e "${GREEN}✅ $agent${NC}"
+        fi
+        AGENT_COUNT=$((AGENT_COUNT + 1))
+    fi
+done
+
+echo ""
+echo "────────────────────────────────────────────────────────────"
+echo "Summary:"
+echo "  - Tasks checked: $TASK_COUNT"
+echo "  - Agents checked: $AGENT_COUNT"
+echo "  - Errors found: $ERRORS"
+echo "────────────────────────────────────────────────────────────"
+
+if [ $ERRORS -gt 0 ]; then
+    echo ""
+    echo -e "${RED}❌ Version validation FAILED${NC}"
+    echo ""
+    echo "How to fix:"
+    echo "1. Add YAML frontmatter to each flagged file"
+    echo "2. Include all required fields (task_name, task_version, etc.)"
+    echo "3. See Story 3.10 for examples"
+    echo ""
+    exit 1
+fi
+
+echo ""
+echo -e "${GREEN}✅ Version validation PASSED${NC}"
+echo ""
+exit 0