diff --git a/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java b/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java
index 4a76100..f115138 100644
--- a/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java
+++ b/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java
@@ -249,6 +249,11 @@ public class ManagedBean<T> extends AbstractClassBean<T>
 
             }.run();
          }
+
+         // Horrible hack to get around the problem with some proxies for groovy objects
+         // being created with the wrong metaClass
+         fixGroovyMetaClass(instance);
+
          if (bean.hasInterceptors())
          {
             return bean.applyInterceptors(instance, ctx);
@@ -596,4 +601,68 @@ public class ManagedBean<T> extends AbstractClassBean<T>
       return proxiable;
    }
 
+   /**
+    * This is a hack to work around an interaction bug with weld and groovy.
+    * For reasons unknown, creating an instance of a bean proxy class returned by <code>InterceptedSubclassFactory</code>
+    * when the underlying bean type is a groovy class will yield a proxy with an incorrect groovy metaclass assigned
+    * to it.  This causes the groovy runtime to throw an exception when methods and properties of the bean are accessed.
+    * This method uses reflection to examine a newly created instance of a bean or proxy to detect this error
+    * condition and fix it if found.
+    * Reflection is used to prevent a dependency on the groovy runtime.
+    * @param o The bean to examine and, if necessary, fix.
+    */
+   public static void fixGroovyMetaClass(Object o)
+   {
+      Class<?> objClass = o.getClass();
+      try
+      {
+         Class<?> clazz = objClass;
+         boolean isGroovy = false;
+         while(clazz != null)
+         {
+            for(Class<?> i : clazz.getInterfaces())
+            {
+               if (i.getName().equals("groovy.lang.GroovyObject"))
+               {
+                  isGroovy=true;
+                  break;
+               }
+            }
+            if (isGroovy)
+            {
+                break;
+            }
+               clazz = clazz.getSuperclass();
+         }
+         if (isGroovy)
+         {
+            Class<?> mcType = Class.forName("groovy.lang.MetaClass");
+
+            // Get the current metaclass for 'o'
+            Object currentMetaClassInst = objClass.getMethod("getMetaClass").invoke(o);
+
+            // Get the handled class type for that metaclass
+            Object currentMetaClassHandledType = currentMetaClassInst.getClass().getMethod("getTheClass").invoke(currentMetaClassInst);
+
+            // If the current metaclass's assigned class is different from objClass
+            // then we have a problem.
+            if (!currentMetaClassHandledType.equals(objClass))
+            {
+               log.trace("Fixing groovy metaClass for instance of "+objClass.getName());
+               // Get the groovy metaclass registry singleton
+               Class registryClass = Class.forName("org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl");
+               Object registry = registryClass.getMethod("getInstance", int.class).invoke(null,1);
+
+               // Get an instance of the correct metaclass and assign it to 'o'
+               Object replacementMetaClassInstance = registry.getClass().getMethod("getMetaClass", Class.class).invoke(registry,objClass);
+               objClass.getMethod("setMetaClass", mcType).invoke(o,replacementMetaClassInstance);
+            }
+         }
+      }
+      catch (Exception e)
+      {
+         log.error("Unable to fix the metaClass for groovy class "+objClass.getName());
+      }
+   }
+
 }
diff --git a/impl/src/main/java/org/jboss/weld/bean/proxy/DecoratorProxyFactory.java b/impl/src/main/java/org/jboss/weld/bean/proxy/DecoratorProxyFactory.java
index 6b0f40a..56c6ba2 100644
--- a/impl/src/main/java/org/jboss/weld/bean/proxy/DecoratorProxyFactory.java
+++ b/impl/src/main/java/org/jboss/weld/bean/proxy/DecoratorProxyFactory.java
@@ -130,7 +130,7 @@ public class DecoratorProxyFactory<T> extends ProxyFactory<T>
             for (Method method : cls.getDeclaredMethods())
             {
                MethodInformation methodInfo = new RuntimeMethodInformation(method);
-               if (!method.getDeclaringClass().getName().equals("java.lang.Object") || method.getName().equals("toString"))
+               if (!method.getDeclaringClass().getName().equals("java.lang.Object") || method.getName().equals("toString") && !excludeGroovy(method))
                {
                   Bytecode methodBody = null;
                   if ((delegateParameterPosition >= 0) && (initializerMethod.equals(method)))
diff --git a/impl/src/main/java/org/jboss/weld/bean/proxy/InterceptedSubclassFactory.java b/impl/src/main/java/org/jboss/weld/bean/proxy/InterceptedSubclassFactory.java
index 5895c9b..260544c 100644
--- a/impl/src/main/java/org/jboss/weld/bean/proxy/InterceptedSubclassFactory.java
+++ b/impl/src/main/java/org/jboss/weld/bean/proxy/InterceptedSubclassFactory.java
@@ -115,7 +115,7 @@ public class InterceptedSubclassFactory<T> extends ProxyFactory<T>
          {
             for (Method method : cls.getDeclaredMethods())
             {
-               if (!Modifier.isFinal(method.getModifiers()) && enhancedMethodSignatures.contains(new MethodSignatureImpl(method)))
+               if (!Modifier.isFinal(method.getModifiers()) && enhancedMethodSignatures.contains(new MethodSignatureImpl(method)) && !excludeGroovy(method))
                {
                   try
                   {
@@ -138,14 +138,17 @@ public class InterceptedSubclassFactory<T> extends ProxyFactory<T>
          {
             for (Method method : c.getMethods())
             {
-               try
-               {
-                  MethodInformation methodInformation = new RuntimeMethodInformation(method);
-                  proxyClassType.addMethod(MethodUtils.makeMethod(AccessFlag.PUBLIC, methodInformation, method.getExceptionTypes(), createSpecialMethodBody(proxyClassType, methodInformation), proxyClassType.getConstPool()));
-                  log.trace("Adding method " + method);
-               }
-               catch (DuplicateMemberException e)
+               if (!excludeGroovy(method))
                {
+                  try
+                  {
+                     MethodInformation methodInformation = new RuntimeMethodInformation(method);
+                     proxyClassType.addMethod(MethodUtils.makeMethod(AccessFlag.PUBLIC, methodInformation, method.getExceptionTypes(), createSpecialMethodBody(proxyClassType, methodInformation), proxyClassType.getConstPool()));
+                     log.trace("Adding method " + method);
+                  }
+                  catch (DuplicateMemberException e)
+                  {
+                  }
                }
             }
          }
diff --git a/impl/src/main/java/org/jboss/weld/bean/proxy/ProxyFactory.java b/impl/src/main/java/org/jboss/weld/bean/proxy/ProxyFactory.java
index db8909e..66ee042 100644
--- a/impl/src/main/java/org/jboss/weld/bean/proxy/ProxyFactory.java
+++ b/impl/src/main/java/org/jboss/weld/bean/proxy/ProxyFactory.java
@@ -106,6 +106,18 @@ public class ProxyFactory<T>
 
    protected static final BytecodeMethodResolver DEFAULT_METHOD_RESOLVER = new DefaultBytecodeMethodResolver();
 
+   protected static final Set<String> GROOVY_METHODS = new HashSet<String>() {{
+      add("invokeMethod");
+      add("getMetaClass");
+      add("setMetaClass");
+      add("metaClass");
+      add("getProperty");
+      add("setProperty");
+      add("$getStaticMetaClass");
+   }};
+
+   protected boolean isGroovyClass = false;
+
    /**
     * created a new proxy factory from a bean instance. The proxy name is
     * generated from the bean id
@@ -183,7 +195,7 @@ public class ProxyFactory<T>
          }
       }
       String beanId = Container.instance().services().get(ContextualStore.class).putIfAbsent(bean);
-      String className = beanId.replace('.', '$').replace(' ', '_').replace('/', '$').replace(';', '$');
+      String className = beanId.replace('.', '$').replace(' ', '_').replace('/', '$').replace(';', '$').replace('-','_');
       return proxyPackage + '.' + className;
    }
 
@@ -355,6 +367,10 @@ public class ProxyFactory<T>
 
    private Class<T> createProxyClass(String proxyClassName) throws Exception
    {
+      // Check for groovy fingerprints on the bean type.  Groovy objects
+      // require special handling
+      isGroovyClass = implementsGroovyObject(beanType);;
+
       ArraySet<Class<?>> specialInterfaces = new ArraySet<Class<?>>(3);
       specialInterfaces.add(LifecycleMixin.class);
       specialInterfaces.add(TargetInstanceProxy.class);
@@ -626,7 +642,7 @@ public class ProxyFactory<T>
          {
             for (Method method : cls.getDeclaredMethods())
             {
-               if (!Modifier.isStatic(method.getModifiers()) && !Modifier.isFinal(method.getModifiers()) && (method.getDeclaringClass() != Object.class || method.getName().equals("toString")))
+               if (!excludeMethod(method))
                {
                   try
                   {
@@ -647,14 +663,17 @@ public class ProxyFactory<T>
          {
             for (Method method : c.getMethods())
             {
-               try
-               {
-                  MethodInformation methodInfo = new RuntimeMethodInformation(method);
-                  proxyClassType.addMethod(MethodUtils.makeMethod(AccessFlag.PUBLIC, methodInfo, method.getExceptionTypes(), createSpecialMethodBody(proxyClassType, methodInfo), proxyClassType.getConstPool()));
-                  log.trace("Adding method " + method);
-               }
-               catch (DuplicateMemberException e)
+               if (!excludeMethod(method))
                {
+                  try
+                  {
+                     MethodInformation methodInfo = new RuntimeMethodInformation(method);
+                     proxyClassType.addMethod(MethodUtils.makeMethod(AccessFlag.PUBLIC, methodInfo, method.getExceptionTypes(), createSpecialMethodBody(proxyClassType, methodInfo), proxyClassType.getConstPool()));
+                     log.trace("Adding method " + method);
+                  }
+                  catch (DuplicateMemberException e)
+                  {
+                  }
                }
             }
          }
@@ -1000,4 +1019,29 @@ public class ProxyFactory<T>
       return resolveClassLoaderForBeanProxy(bean, TypeInfo.of(bean.getTypes()));
    }
 
+   protected boolean excludeMethod(Method method)
+   {
+      return Modifier.isStatic(method.getModifiers()) || Modifier.isFinal(method.getModifiers()) || method.getDeclaringClass() == Object.class || method.getName().equals("toString") || excludeGroovy(method);
+   }
+
+   protected boolean excludeGroovy(Method method)
+   {
+      return isGroovyClass && (GROOVY_METHODS.contains(method.getName()));
+   }
+   
+   private boolean implementsGroovyObject(Class clazz)
+   {
+      while(clazz != null)
+      {
+         for(Class<?> i : clazz.getInterfaces())
+         {
+            if ("groovy.lang.GroovyObject".equals(i.getName()))
+            {
+                return true;
+            }
+         }
+         clazz = clazz.getSuperclass();
+      }   
+      return false;
+   }
 }
