diff --git a/java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRunTaskProvider.java b/java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRunTaskProvider.java
index 667bd73ea91e..c7bab6b06867 100644
--- a/java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRunTaskProvider.java
+++ b/java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRunTaskProvider.java
@@ -109,7 +109,7 @@ public class BuildArtifactsBeforeRunTaskProvider extends BeforeRunTaskProvider<B
   @Override
   public String getDescription(BuildArtifactsBeforeRunTask task) {
     final List<ArtifactPointer> pointers = task.getArtifactPointers();
-    if (!task.isEnabled() || pointers.isEmpty()) {
+    if (pointers.isEmpty()) {
       return CompilerBundle.message("build.artifacts.before.run.description.empty");
     }
     if (pointers.size() == 1) {
diff --git a/java/execution/impl/src/com/intellij/execution/application/ApplicationConfigurationType.java b/java/execution/impl/src/com/intellij/execution/application/ApplicationConfigurationType.java
index 7d1ea6033393..032d56d85e1e 100644
--- a/java/execution/impl/src/com/intellij/execution/application/ApplicationConfigurationType.java
+++ b/java/execution/impl/src/com/intellij/execution/application/ApplicationConfigurationType.java
@@ -16,7 +16,6 @@
 package com.intellij.execution.application;
 
 import com.intellij.execution.ExecutionBundle;
-import com.intellij.execution.RunConfigurationExtension;
 import com.intellij.execution.configuration.ConfigurationFactoryEx;
 import com.intellij.execution.configurations.ConfigurationFactory;
 import com.intellij.execution.configurations.ConfigurationType;
@@ -48,11 +47,6 @@ public class ApplicationConfigurationType implements ConfigurationType {
         return new ApplicationConfiguration("", project, ApplicationConfigurationType.this);
       }
 
-      @Override
-      public Icon getIcon(@NotNull final RunConfiguration configuration) {
-        return getIcon();
-      }
-
       @Override
       public void onNewConfigurationCreated(@NotNull RunConfiguration configuration) {
         ((ModuleBasedConfiguration)configuration).onNewConfigurationCreated();
diff --git a/platform/lang-api/src/com/intellij/execution/BeforeRunTask.java b/platform/lang-api/src/com/intellij/execution/BeforeRunTask.java
index fad6015d02f0..5eb1ed114b42 100644
--- a/platform/lang-api/src/com/intellij/execution/BeforeRunTask.java
+++ b/platform/lang-api/src/com/intellij/execution/BeforeRunTask.java
@@ -55,6 +55,8 @@ public abstract class BeforeRunTask<T extends BeforeRunTask> implements Cloneabl
     if (attribValue == null) {
       attribValue = element.getAttributeValue("value"); // maintain compatibility with old format
     }
+    if (attribValue == null)
+      attribValue = "true";
     myIsEnabled = Boolean.valueOf(attribValue).booleanValue();
   }
 
diff --git a/platform/lang-impl/src/com/intellij/execution/RunManagerEx.java b/platform/lang-impl/src/com/intellij/execution/RunManagerEx.java
index db6ea1442367..13a16c6fd8f2 100644
--- a/platform/lang-impl/src/com/intellij/execution/RunManagerEx.java
+++ b/platform/lang-impl/src/com/intellij/execution/RunManagerEx.java
@@ -53,7 +53,10 @@ public abstract class RunManagerEx extends RunManager {
   @NotNull
   public abstract RunnerAndConfigurationSettings createConfiguration(String name, ConfigurationFactory type);
 
-  public abstract void addConfiguration(RunnerAndConfigurationSettings settings, boolean isShared, List<BeforeRunTask> tasks);
+  public abstract void addConfiguration(RunnerAndConfigurationSettings settings,
+                                        boolean isShared,
+                                        List<BeforeRunTask> tasks,
+                                        boolean addTemplateTasksIfAbsent);
 
   public abstract void addConfiguration(final RunnerAndConfigurationSettings settings, final boolean isShared);
 
@@ -62,14 +65,11 @@ public abstract class RunManagerEx extends RunManager {
   @NotNull
   public abstract List<BeforeRunTask> getBeforeRunTasks(RunConfiguration settings);
 
-  @NotNull
-  public abstract List<BeforeRunTask> getBeforeRunTasks(RunConfiguration settings, boolean includeOnlyActiveTasks);
-
   @NotNull
   public abstract <T extends BeforeRunTask> List<T> getBeforeRunTasks(RunConfiguration settings, Key<T> taskProviderID);
 
   @NotNull
-  public abstract <T extends BeforeRunTask> List<T> getBeforeRunTasks(Key<T> taskProviderID, boolean includeOnlyActiveTasks);
+  public abstract <T extends BeforeRunTask> List<T> getBeforeRunTasks(Key<T> taskProviderID);
 
   public abstract RunnerAndConfigurationSettings findConfigurationByName(@Nullable final String name);
 
diff --git a/platform/lang-impl/src/com/intellij/execution/actions/CreateAction.java b/platform/lang-impl/src/com/intellij/execution/actions/CreateAction.java
index af9ce1aed324..d7fd9e783393 100644
--- a/platform/lang-impl/src/com/intellij/execution/actions/CreateAction.java
+++ b/platform/lang-impl/src/com/intellij/execution/actions/CreateAction.java
@@ -122,7 +122,8 @@ public class CreateAction extends BaseRunConfigurationAction {
       final RunnerAndConfigurationSettings configuration = context.getConfiguration();
       final RunnerAndConfigurationSettings template = runManager.getConfigurationTemplate(configuration.getFactory());
       final RunConfiguration templateConfiguration = template.getConfiguration();
-      runManager.addConfiguration(configuration, runManager.isConfigurationShared(template), runManager.getBeforeRunTasks( templateConfiguration));
+      runManager.addConfiguration(configuration, runManager.isConfigurationShared(template), runManager.getBeforeRunTasks( templateConfiguration),
+                                  false);
       runManager.setActiveConfiguration(configuration);
     }
   }
@@ -139,7 +140,7 @@ public class CreateAction extends BaseRunConfigurationAction {
         final RunManagerImpl runManager = (RunManagerImpl)context.getRunManager();
         runManager.addConfiguration(configuration,
                                     runManager.isConfigurationShared(configuration),
-                                    runManager.getBeforeRunTasks(configuration.getConfiguration()));
+                                    runManager.getBeforeRunTasks(configuration.getConfiguration()), false);
         runManager.setActiveConfiguration(configuration);
       }
     }
diff --git a/platform/lang-impl/src/com/intellij/execution/impl/BaseExecuteBeforeRunDialog.java b/platform/lang-impl/src/com/intellij/execution/impl/BaseExecuteBeforeRunDialog.java
index fe59622cc785..31284e67419a 100644
--- a/platform/lang-impl/src/com/intellij/execution/impl/BaseExecuteBeforeRunDialog.java
+++ b/platform/lang-impl/src/com/intellij/execution/impl/BaseExecuteBeforeRunDialog.java
@@ -235,7 +235,7 @@ public abstract class BaseExecuteBeforeRunDialog<T extends BeforeRunTask> extend
         tasks.remove(task);
       }
     }
-    runManager.setBeforeRunTasks(config, tasks);
+    runManager.setBeforeRunTasks(config, tasks, false);
   }
 
   protected abstract void update(T task);
diff --git a/platform/lang-impl/src/com/intellij/execution/impl/BeforeRunStepsPanel.java b/platform/lang-impl/src/com/intellij/execution/impl/BeforeRunStepsPanel.java
index cc2b4687ea0f..29e34c124e0a 100644
--- a/platform/lang-impl/src/com/intellij/execution/impl/BeforeRunStepsPanel.java
+++ b/platform/lang-impl/src/com/intellij/execution/impl/BeforeRunStepsPanel.java
@@ -120,7 +120,7 @@ class BeforeRunStepsPanel extends JPanel {
     myRunConfiguration = settings.getConfiguration();
 
     originalTasks.clear();
-    originalTasks.addAll(RunManagerImpl.getInstanceImpl(myRunConfiguration.getProject()).getBeforeRunTasks(myRunConfiguration, true));
+    originalTasks.addAll(RunManagerImpl.getInstanceImpl(myRunConfiguration.getProject()).getBeforeRunTasks(myRunConfiguration));
     myModel.replaceAll(originalTasks);
     myShowSettingsBeforeRunCheckBox.setSelected(settings.isEditBeforeRun());
     myShowSettingsBeforeRunCheckBox.setEnabled(!(myRunConfiguration instanceof UnknownRunConfiguration));
@@ -205,11 +205,11 @@ class BeforeRunStepsPanel extends JPanel {
         = (RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask)task;
       RunConfiguration configuration = runTask.getSettings().getConfiguration();
 
-      List<BeforeRunTask> tasks = RunManagerImpl.getInstanceImpl(configuration.getProject()).getBeforeRunTasks(configuration, true);
+      List<BeforeRunTask> tasks = RunManagerImpl.getInstanceImpl(configuration.getProject()).getBeforeRunTasks(configuration);
       for (BeforeRunTask beforeRunTask : tasks) {
         if (beforeRunTask instanceof RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask) {
-          configurationSet.add(((RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask)beforeRunTask).getSettings().getConfiguration());
-          getAllRunBeforeRuns(beforeRunTask, configurationSet);
+          if (configurationSet.add(((RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask)beforeRunTask).getSettings().getConfiguration()))
+            getAllRunBeforeRuns(beforeRunTask, configurationSet);
         }
       }
     }
diff --git a/platform/lang-impl/src/com/intellij/execution/impl/ConfigurationSettingsEditorWrapper.java b/platform/lang-impl/src/com/intellij/execution/impl/ConfigurationSettingsEditorWrapper.java
index 7d1d7a436db0..61835db7f5b3 100644
--- a/platform/lang-impl/src/com/intellij/execution/impl/ConfigurationSettingsEditorWrapper.java
+++ b/platform/lang-impl/src/com/intellij/execution/impl/ConfigurationSettingsEditorWrapper.java
@@ -114,7 +114,7 @@ public class ConfigurationSettingsEditorWrapper extends SettingsEditor<RunnerAnd
   private void doApply(final RunnerAndConfigurationSettings settings) {
     final RunConfiguration runConfiguration = settings.getConfiguration();
     final RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(runConfiguration.getProject());
-    runManager.setBeforeRunTasks(runConfiguration, myBeforeRunStepsPanel.getTasks(true));
+    runManager.setBeforeRunTasks(runConfiguration, myBeforeRunStepsPanel.getTasks(true), false);
     runManager.shareConfiguration(runConfiguration, myStoreProjectConfiguration);
     RunnerAndConfigurationSettings runManagerSettings = runManager.getSettings(runConfiguration);
     if (runManagerSettings != null) {
@@ -125,7 +125,7 @@ public class ConfigurationSettingsEditorWrapper extends SettingsEditor<RunnerAnd
   }
 
   public List<BeforeRunTask> getStepsBeforeLaunch() {
-    return Collections.unmodifiableList(myBeforeRunStepsPanel.getTasks(false));
+    return Collections.unmodifiableList(myBeforeRunStepsPanel.getTasks(true));
   }
 
   public boolean isStoreProjectConfiguration() {
diff --git a/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java b/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java
index f15e9fa2c222..484cb35ac961 100644
--- a/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java
@@ -97,12 +97,7 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom
       final RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(myProject);
 
       final List<BeforeRunTask> activeTasks = new ArrayList<BeforeRunTask>();
-        final List<BeforeRunTask> tasks = runManager.getBeforeRunTasks(runConfiguration);
-        for (BeforeRunTask task : tasks) {
-          if (task != null && task.isEnabled()) {
-            activeTasks.add(task);
-          }
-        }
+      activeTasks.addAll(runManager.getBeforeRunTasks(runConfiguration));
 
       ConfigurationPerRunnerSettings configurationSettings = state != null ? state.getConfigurationSettings() : null;
       final DataContext projectContext = SimpleDataContext.getProjectContext(myProject);
diff --git a/platform/lang-impl/src/com/intellij/execution/impl/RunConfigurable.java b/platform/lang-impl/src/com/intellij/execution/impl/RunConfigurable.java
index f462ba509a22..75a880070fbd 100644
--- a/platform/lang-impl/src/com/intellij/execution/impl/RunConfigurable.java
+++ b/platform/lang-impl/src/com/intellij/execution/impl/RunConfigurable.java
@@ -164,12 +164,7 @@ class RunConfigurable extends BaseConfigurable {
             if (userObject instanceof SingleConfigurationConfigurable) {
               final SingleConfigurationConfigurable<?> settings = (SingleConfigurationConfigurable)userObject;
               RunnerAndConfigurationSettings snapshot;
-              try {
-                snapshot = settings.getSnapshot();
-              }
-              catch (ConfigurationException e) {
-                snapshot = settings.getSettings();
-              }
+              snapshot = settings.getSettings();
               configuration = settings.getConfiguration();
               name = settings.getNameText();
               setIcon(ProgramRunnerUtil.getConfigurationIcon(snapshot, !settings.isValid(), runManager.isTemporary(configuration)));
@@ -645,7 +640,7 @@ class RunConfigurable extends BaseConfigurable {
 
     for (RunConfigurationBean each : stableConfigurations) {
       toDeleteSettings.remove(each.getSettings());
-      manager.addConfiguration(each.getSettings(), each.isShared(), each.getStepsBeforeLaunch());
+      manager.addConfiguration(each.getSettings(), each.isShared(), each.getStepsBeforeLaunch(), false);
     }
 
     RunnerAndConfigurationSettings selected = manager.getSelectedConfiguration();
diff --git a/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java b/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java
index 25555d1ee971..cc09148e22af 100644
--- a/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java
@@ -67,7 +67,6 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
   protected static final String SELECTED_ATTR = "selected";
   @NonNls private static final String METHOD = "method";
   @NonNls private static final String OPTION = "option";
-  @NonNls private static final String VALUE = "value";
 
   private List<Element> myUnknownElements = null;
   private JDOMExternalizableStringList myOrder = new JDOMExternalizableStringList();
@@ -240,7 +239,7 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
 
   public void addConfiguration(RunnerAndConfigurationSettings settings,
                                boolean shared,
-                               List<BeforeRunTask> tasks) {
+                               List<BeforeRunTask> tasks, boolean addEnabledTemplateTasksIfAbsent) {
     final RunConfiguration configuration = settings.getConfiguration();
 
     Integer existingId = findConfigurationIdByUniqueName(getUniqueName(settings));
@@ -257,7 +256,8 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
     checkRecentsLimit();
 
     mySharedConfigurations.put(newId, shared);
-    setBeforeRunTasks(configuration, tasks);
+    getTemplateBeforeRunTask(configuration);
+    setBeforeRunTasks(configuration, tasks, addEnabledTemplateTasksIfAbsent);
 
     if (existingSettings == settings) {
       myDispatcher.getMulticaster().runConfigurationChanged(settings);
@@ -455,13 +455,30 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
       if (!settings.isTemplate()) {
         List<BeforeRunTask> beforeRunTasks = getBeforeRunTasks(getConfigurationTemplate(settings.getFactory()).getConfiguration());
         templateTasks = new HashMap<Key<BeforeRunTask>, BeforeRunTask>();
-        for (BeforeRunTask task : beforeRunTasks) {
-          templateTasks.put(task.getProviderId(), task);
+        for (BeforeRunTask templateTask : beforeRunTasks) {
+          templateTasks.put(templateTask.getProviderId(), templateTask);
+          if (templateTask.isEnabled()) {
+            boolean found = false;
+            for (BeforeRunTask realTask : tasks) {
+              if (realTask.getProviderId() == templateTask.getProviderId()) {
+                found = true;
+                break;
+              }
+            }
+            if (!found) {
+              BeforeRunTask clone = templateTask.clone();
+              clone.setEnabled(false);
+              tasks.add(0, clone);
+            }
+          }
         }
       }
       for (BeforeRunTask task : tasks) {
-        if (templateTasks != null && task.equals(templateTasks.get(task.getProviderId())))
-          continue; // not neccesary saving if the task is the same as template
+        if (templateTasks != null) {
+          BeforeRunTask templateTask = templateTasks.get(task.getProviderId());
+          if (task.equals(templateTask))
+            continue; // not neccesary saving if the task is the same as template
+        }
         final Element child = new Element(OPTION);
         child.setAttribute(NAME_ATTR, task.getProviderId().toString());
         task.writeExternal(child);
@@ -471,6 +488,7 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
     }
   }
 
+
   public void readExternal(final Element parentNode) throws InvalidDataException {
     clear();
 
@@ -573,10 +591,10 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
     final List<BeforeRunTask> tasks = readStepsBeforeRun(methodsElement, settings);
     if (settings.isTemplate()) {
       myTemplateConfigurationsMap.put(factory.getType().getId() + "." + factory.getName(), settings);
-      setBeforeRunTasks(settings.getConfiguration(), tasks);
+      setBeforeRunTasks(settings.getConfiguration(), tasks, true);
     }
     else {
-      addConfiguration(settings, isShared, tasks);
+      addConfiguration(settings, isShared, tasks, true);
       if (Boolean.valueOf(element.getAttributeValue(SELECTED_ATTR)).booleanValue()) { //to support old style
         setSelectedConfiguration(settings);
       }
@@ -657,7 +675,7 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
     invalidateConfigurationIcon(tempConfiguration);
 
     addConfiguration(tempConfiguration, isConfigurationShared(tempConfiguration),
-                     getBeforeRunTasks(tempConfiguration.getConfiguration()));
+                     getBeforeRunTasks(tempConfiguration.getConfiguration()), false);
     setActiveConfiguration(tempConfiguration);
   }
 
@@ -720,48 +738,30 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
   }
 
   @NotNull
-  public <T extends BeforeRunTask> List<T> getBeforeRunTasks(Key<T> taskProviderID, boolean includeOnlyActiveTasks) {
+  public <T extends BeforeRunTask> List<T> getBeforeRunTasks(Key<T> taskProviderID) {
     final List<T> tasks = new ArrayList<T>();
-    if (includeOnlyActiveTasks) {
-      final List<RunnerAndConfigurationSettings> checkedTemplates = new ArrayList<RunnerAndConfigurationSettings>();
-      List<RunnerAndConfigurationSettings> settingsList = new ArrayList<RunnerAndConfigurationSettings>(myConfigurations.values());
-      for (RunnerAndConfigurationSettings settings : settingsList) {
-        final List<BeforeRunTask> runTasks = getBeforeRunTasks(settings.getConfiguration());
-        for (BeforeRunTask task : runTasks) {
-          if (task != null && task.isEnabled() && task.getProviderId() == taskProviderID) {
-            tasks.add((T)task);
-          }
-          else {
-            final RunnerAndConfigurationSettings template = getConfigurationTemplate(settings.getFactory());
-            if (!checkedTemplates.contains(template)) {
-              checkedTemplates.add(template);
-              final List<BeforeRunTask> templateTasks = getBeforeRunTasks(template.getConfiguration());
-              for (BeforeRunTask templateTask : templateTasks) {
-                if (templateTask != null && templateTask.isEnabled() && templateTask.getProviderId() == taskProviderID) {
-                  tasks.add((T)templateTask);
-                }
+    final List<RunnerAndConfigurationSettings> checkedTemplates = new ArrayList<RunnerAndConfigurationSettings>();
+    List<RunnerAndConfigurationSettings> settingsList = new ArrayList<RunnerAndConfigurationSettings>(myConfigurations.values());
+    for (RunnerAndConfigurationSettings settings : settingsList) {
+      final List<BeforeRunTask> runTasks = getBeforeRunTasks(settings.getConfiguration());
+      for (BeforeRunTask task : runTasks) {
+        if (task != null && task.isEnabled() && task.getProviderId() == taskProviderID) {
+          tasks.add((T)task);
+        }
+        else {
+          final RunnerAndConfigurationSettings template = getConfigurationTemplate(settings.getFactory());
+          if (!checkedTemplates.contains(template)) {
+            checkedTemplates.add(template);
+            final List<BeforeRunTask> templateTasks = getBeforeRunTasks(template.getConfiguration());
+            for (BeforeRunTask templateTask : templateTasks) {
+              if (templateTask != null && templateTask.isEnabled() && templateTask.getProviderId() == taskProviderID) {
+                tasks.add((T)templateTask);
               }
             }
           }
         }
       }
     }
-    else {
-      for (RunnerAndConfigurationSettings settings : myTemplateConfigurationsMap.values()) {
-        final List<BeforeRunTask> tasks_ = getBeforeRunTasks(settings.getConfiguration());
-        for (BeforeRunTask task : tasks_) {
-          if (task != null && task.getProviderId() == taskProviderID)
-          tasks.add((T)task);
-        }
-      }
-      for (RunnerAndConfigurationSettings settings : myConfigurations.values()) {
-        final List<BeforeRunTask> tasks_ = getBeforeRunTasks(settings.getConfiguration());
-        for (BeforeRunTask task : tasks_) {
-          if (task != null && task.getProviderId() == taskProviderID)
-            tasks.add((T)task);
-        }
-      }
-    }
     return tasks;
   }
 
@@ -826,32 +826,25 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
 
   @NotNull
   public List<BeforeRunTask> getBeforeRunTasks(final RunConfiguration settings) {
-    return getBeforeRunTasks(settings, false);
-  }
-    @NotNull
-  @Override
-  public List<BeforeRunTask> getBeforeRunTasks(RunConfiguration settings, boolean includeOnlyActiveTasks) {
     final List<BeforeRunTask> tasks = myConfigurationToBeforeTasksMap.get(settings);
     if (tasks != null) {
-      return getCopies(tasks, includeOnlyActiveTasks);
+      return getCopies(tasks);
     }
-    return getTemplateBeforeRunTask(settings, includeOnlyActiveTasks);
+    return getTemplateBeforeRunTask(settings);
   }
 
-  private List<BeforeRunTask> getTemplateBeforeRunTask(RunConfiguration settings, boolean includeOnlyActiveTasks) {
+  private List<BeforeRunTask> getTemplateBeforeRunTask(RunConfiguration settings) {
     final RunnerAndConfigurationSettings template = getConfigurationTemplate(settings.getFactory());
     final List<BeforeRunTask> templateTasks = myConfigurationToBeforeTasksMap.get(template.getConfiguration());
     if (templateTasks != null) {
-      return getCopies(templateTasks, includeOnlyActiveTasks);
+      return getCopies(templateTasks);
     }
 
     final List<BeforeRunTask> _tasks = new ArrayList<BeforeRunTask>();
     for (BeforeRunTaskProvider<? extends BeforeRunTask> provider : Extensions
       .getExtensions(BeforeRunTaskProvider.EXTENSION_POINT_NAME, myProject)) {
       BeforeRunTask task = provider.createTask(settings);
-      if (task != null) {
-        if (includeOnlyActiveTasks && !task.isEnabled())
-          continue;
+      if (task != null && task.isEnabled()) {
         Key<? extends BeforeRunTask> providerID = provider.getId();
         _tasks.add(task);
         settings.getFactory().configureBeforeRunTaskDefaults(providerID, task);
@@ -861,11 +854,11 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
   }
 
   @NotNull
-  private static List<BeforeRunTask> getCopies(List<BeforeRunTask> original, boolean includeOnlyActiveTasks) {
+  private static List<BeforeRunTask> getCopies(List<BeforeRunTask> original) {
     List<BeforeRunTask> result = new ArrayList<BeforeRunTask>();
     if (original != null) {
       for (BeforeRunTask task : original) {
-        if (includeOnlyActiveTasks && !task.isEnabled())
+        if (!task.isEnabled())
           continue;
         result.add(task.clone());
       }
@@ -883,18 +876,20 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
     if (shouldFire) fireRunConfigurationChanged(settings);
   }
 
-  public final void setBeforeRunTasks(final RunConfiguration runConfiguration, List<BeforeRunTask> tasks) {
-    List<BeforeRunTask> templates = getTemplateBeforeRunTask(runConfiguration, false);
-    Set<Key<BeforeRunTask>> idsToSet = new HashSet<Key<BeforeRunTask>>();
+  public final void setBeforeRunTasks(final RunConfiguration runConfiguration, @NotNull List<BeforeRunTask> tasks, boolean addEnabledTemplateTasksIfAbsent) {
     List<BeforeRunTask> result = new ArrayList<BeforeRunTask>(tasks);
-    for (BeforeRunTask task : tasks) {
-      idsToSet.add(task.getProviderId());
-    }
-    int i = 0;
-    for (BeforeRunTask template : templates) {
-      if (!idsToSet.contains(template.getProviderId())) {
-        result.add(i, template);
-        i++;
+    if (addEnabledTemplateTasksIfAbsent) {
+      List<BeforeRunTask> templates = getTemplateBeforeRunTask(runConfiguration);
+      Set<Key<BeforeRunTask>> idsToSet = new HashSet<Key<BeforeRunTask>>();
+      for (BeforeRunTask task : tasks) {
+        idsToSet.add(task.getProviderId());
+      }
+      int i = 0;
+      for (BeforeRunTask template : templates) {
+        if (!idsToSet.contains(template.getProviderId())) {
+          result.add(i, template);
+          i++;
+        }
       }
     }
     myConfigurationToBeforeTasksMap.put(runConfiguration, result);
@@ -907,7 +902,7 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
   }
 
   public void addConfiguration(final RunnerAndConfigurationSettings settings, final boolean isShared) {
-    addConfiguration(settings, isShared, new ArrayList<BeforeRunTask>());
+    addConfiguration(settings, isShared, new ArrayList<BeforeRunTask>(), false);
   }
 
   public static RunManagerImpl getInstanceImpl(final Project project) {
diff --git a/platform/platform-api/src/com/intellij/ui/CollectionListModel.java b/platform/platform-api/src/com/intellij/ui/CollectionListModel.java
index 161529538472..12ddaa9bff41 100644
--- a/platform/platform-api/src/com/intellij/ui/CollectionListModel.java
+++ b/platform/platform-api/src/com/intellij/ui/CollectionListModel.java
@@ -98,4 +98,9 @@ public class CollectionListModel<T> extends AbstractListModel {
     removeAll();
     add(elements);
   }
+
+  @Override
+  public String toString() {
+    return getClass().getName() + " (" + getSize() + " elements)";
+  }
 }
diff --git a/platform/testFramework/src/com/intellij/mock/MockRunManager.java b/platform/testFramework/src/com/intellij/mock/MockRunManager.java
index 4f47bbd45014..8cb22fd675be 100644
--- a/platform/testFramework/src/com/intellij/mock/MockRunManager.java
+++ b/platform/testFramework/src/com/intellij/mock/MockRunManager.java
@@ -96,7 +96,10 @@ public class MockRunManager extends RunManagerEx {
   }
 
   @Override
-  public void addConfiguration(RunnerAndConfigurationSettings settings, boolean isShared, List<BeforeRunTask> tasks) {
+  public void addConfiguration(RunnerAndConfigurationSettings settings,
+                               boolean isShared,
+                               List<BeforeRunTask> tasks,
+                               boolean addTemplateTasksIfAbsent) {
   }
 
   @Override
@@ -111,18 +114,12 @@ public class MockRunManager extends RunManagerEx {
   @NotNull
   @Override
   public List<BeforeRunTask> getBeforeRunTasks(RunConfiguration settings) {
-    return null;
-  }
-
-  @NotNull
-  @Override
-  public List<BeforeRunTask> getBeforeRunTasks(RunConfiguration settings, boolean includeOnlyActiveTasks) {
     return Collections.emptyList();
   }
 
   @NotNull
   @Override
-  public <T extends BeforeRunTask> List<T> getBeforeRunTasks(Key<T> taskProviderID, boolean includeOnlyActiveTasks) {
+  public <T extends BeforeRunTask> List<T> getBeforeRunTasks(Key<T> taskProviderID) {
     return Collections.emptyList();
   }
 
diff --git a/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntTargetNodeDescriptor.java b/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntTargetNodeDescriptor.java
index b5fe79ba9959..12450fafdb4b 100644
--- a/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntTargetNodeDescriptor.java
+++ b/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntTargetNodeDescriptor.java
@@ -97,7 +97,7 @@ final class AntTargetNodeDescriptor extends AntNodeDescriptor {
     final RunManagerEx runManager = RunManagerEx.getInstanceEx(myProject);
     final VirtualFile vFile = buildFile.getVirtualFile();
     if (vFile != null) {
-      for (AntBeforeRunTask task : runManager.getBeforeRunTasks(AntBeforeRunTaskProvider.ID, true)) {
+      for (AntBeforeRunTask task : runManager.getBeforeRunTasks(AntBeforeRunTaskProvider.ID)) {
         if (task.isRunningTarget(myTarget)) {
           myHighlightedText.getEnding().addText(" (Before Run/Debug)", ourPostfixAttributes);
           break;
diff --git a/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTask.java b/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTask.java
index da5fe11c2bc6..9612ca7417f2 100644
--- a/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTask.java
+++ b/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTask.java
@@ -69,9 +69,6 @@ public class AntBeforeRunTask extends BeforeRunTask<AntBeforeRunTask>{
   }
 
   public boolean isRunningTarget(AntBuildTarget target) {
-    if (!isEnabled()) {
-      return false;
-    }
     final VirtualFile vFile = target.getModel().getBuildFile().getVirtualFile();
     if (vFile == null) {
       return false;
diff --git a/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTaskProvider.java b/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTaskProvider.java
index 96dffca033d0..d1b589dba850 100644
--- a/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTaskProvider.java
+++ b/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTaskProvider.java
@@ -66,7 +66,7 @@ public class AntBeforeRunTaskProvider extends BeforeRunTaskProvider<AntBeforeRun
   @Override
   public String getDescription(AntBeforeRunTask task) {
     final String targetName = task.getTargetName();
-    if (targetName == null && !task.isEnabled()) {
+    if (targetName == null) {
       return AntBundle.message("ant.target.before.run.description.empty");
     }
     return AntBundle.message("ant.target.before.run.description", targetName != null? targetName : "<not selected>");
@@ -144,7 +144,7 @@ public class AntBeforeRunTaskProvider extends BeforeRunTaskProvider<AntBeforeRun
 
   public void handleTargetRename(String oldName, String newName) {
     final RunManagerEx runManager = RunManagerEx.getInstanceEx(myProject);
-    for (AntBeforeRunTask task : runManager.getBeforeRunTasks(ID, false)) {
+    for (AntBeforeRunTask task : runManager.getBeforeRunTasks(ID)) {
       if (oldName.equals(task.getTargetName())) {
         task.setTargetName(newName);
       }
diff --git a/plugins/junit/src/com/intellij/execution/junit/JUnitConfigurationType.java b/plugins/junit/src/com/intellij/execution/junit/JUnitConfigurationType.java
index 594a054fdb0e..6a018d006d63 100644
--- a/plugins/junit/src/com/intellij/execution/junit/JUnitConfigurationType.java
+++ b/plugins/junit/src/com/intellij/execution/junit/JUnitConfigurationType.java
@@ -17,7 +17,6 @@
 package com.intellij.execution.junit;
 
 import com.intellij.execution.ExecutionBundle;
-import com.intellij.execution.RunConfigurationExtension;
 import com.intellij.execution.configuration.ConfigurationFactoryEx;
 import com.intellij.execution.configurations.ConfigurationFactory;
 import com.intellij.execution.configurations.ConfigurationType;
@@ -43,11 +42,6 @@ public class JUnitConfigurationType implements ConfigurationType {
         return new JUnitConfiguration("", project, this);
       }
 
-      @Override
-      public Icon getIcon(@NotNull final RunConfiguration configuration) {
-        return getIcon();
-      }
-
       @Override
       public void onNewConfigurationCreated(@NotNull RunConfiguration configuration) {
         ((ModuleBasedConfiguration)configuration).onNewConfigurationCreated();
diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenBeforeRunTasksProvider.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenBeforeRunTasksProvider.java
index 876ae70e0c41..3cb197d11d9d 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenBeforeRunTasksProvider.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenBeforeRunTasksProvider.java
@@ -69,10 +69,8 @@ public class MavenBeforeRunTasksProvider extends BeforeRunTaskProvider<MavenBefo
   @Override
   public String getDescription(MavenBeforeRunTask task) {
     String desc = null;
-    if (task.isEnabled()) {
-      Pair<MavenProject, String> projectAndGoal = getProjectAndGoalChecked(task);
-      if (projectAndGoal != null) desc = projectAndGoal.first.getDisplayName() + ":" + projectAndGoal.second;
-    }
+    Pair<MavenProject, String> projectAndGoal = getProjectAndGoalChecked(task);
+    if (projectAndGoal != null) desc = projectAndGoal.first.getDisplayName() + ":" + projectAndGoal.second;
     return desc == null
            ? TasksBundle.message("maven.tasks.before.run.empty")
            : TasksBundle.message("maven.tasks.before.run", desc);
diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenTasksManager.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenTasksManager.java
index 55cdc3ae5d16..303d91189726 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenTasksManager.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenTasksManager.java
@@ -162,7 +162,7 @@ public class MavenTasksManager extends MavenSimpleProjectComponent implements Pe
       }
     }
     RunManagerEx runManager = RunManagerEx.getInstanceEx(myProject);
-    for (MavenBeforeRunTask each : runManager.getBeforeRunTasks(MavenBeforeRunTasksProvider.ID, true)) {
+    for (MavenBeforeRunTask each : runManager.getBeforeRunTasks(MavenBeforeRunTasksProvider.ID)) {
       if (each.isFor(project, goal)) {
         result.add(TasksBundle.message("maven.tasks.goal.before.run"));
         break;
diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/actions/ToggleBeforeRunTaskAction.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/actions/ToggleBeforeRunTaskAction.java
index 62949c591b88..cbbf24fc8c6a 100644
--- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/actions/ToggleBeforeRunTaskAction.java
+++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/actions/ToggleBeforeRunTaskAction.java
@@ -40,8 +40,8 @@ public class ToggleBeforeRunTaskAction extends MavenToggleAction {
     final DataContext context = e.getDataContext();
     final Pair<MavenProject, String> desc = getTaskDesc(context);
     if (desc != null) {
-      for (MavenBeforeRunTask each : getRunManager(context).getBeforeRunTasks(MavenBeforeRunTasksProvider.ID, true)) {
-        if (each.isEnabled() && each.isFor(desc.first, desc.second)) return true;
+      for (MavenBeforeRunTask each : getRunManager(context).getBeforeRunTasks(MavenBeforeRunTasksProvider.ID)) {
+        if (each.isFor(desc.first, desc.second)) return true;
       }
     }
     return false;
diff --git a/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfigurationType.java b/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfigurationType.java
index 08cb9c134888..7dfc48dfa35b 100644
--- a/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfigurationType.java
+++ b/plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfigurationType.java
@@ -23,9 +23,7 @@
 package com.theoryinpractice.testng.configuration;
 
 import com.intellij.execution.Location;
-import com.intellij.execution.RunConfigurationExtension;
 import com.intellij.execution.RunManagerEx;
-import com.intellij.execution.RunnerAndConfigurationSettings;
 import com.intellij.execution.configuration.ConfigurationFactoryEx;
 import com.intellij.execution.configurations.*;
 import com.intellij.execution.impl.RunManagerImpl;
@@ -57,11 +55,6 @@ public class TestNGConfigurationType implements ConfigurationType
                 return new TestNGConfiguration("", project, this);
             }
 
-          @Override
-          public Icon getIcon(@NotNull final RunConfiguration configuration) {
-            return ICON;
-          }
-
           @Override
           public void onNewConfigurationCreated(@NotNull RunConfiguration configuration) {
             ((ModuleBasedConfiguration)configuration).onNewConfigurationCreated();