diff --git a/.idea/runConfigurations/py_test_for_tests_control_test_EVC_test_EVC.xml b/.idea/runConfigurations/py_test_for_tests_control_test_EVC_test_EVC.xml
index 895e167d597..b32bbb89e18 100644
--- a/.idea/runConfigurations/py_test_for_tests_control_test_EVC_test_EVC.xml
+++ b/.idea/runConfigurations/py_test_for_tests_control_test_EVC_test_EVC.xml
@@ -1,12 +1,13 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" factoryName="py.test" name="py.test for tests.control.test_EVC.test_EVC" nameIsGenerated="true" singleton="true" type="tests">
+  <configuration default="false" name="py.test for tests.control.test_EVC.test_EVC" type="tests" factoryName="py.test" singleton="true" nameIsGenerated="true">
+    <module name="PsyNeuLink (Dropbox)" />
     <module name="" />
     <option name="INTERPRETER_OPTIONS" value="" />
     <option name="PARENT_ENVS" value="true" />
     <envs>
       <env name="PYTHONUNBUFFERED" value="1" />
     </envs>
-    <option name="SDK_HOME" value="" />
+    <option name="SDK_HOME" value="$USER_HOME$/anaconda/envs/python35/bin/python" />
     <option name="WORKING_DIRECTORY" value="" />
     <option name="IS_MODULE_SDK" value="false" />
     <option name="ADD_CONTENT_ROOTS" value="true" />
diff --git a/psyneulink/components/component.py b/psyneulink/components/component.py
index bb7fa8d19a1..ee319bf6a65 100644
--- a/psyneulink/components/component.py
+++ b/psyneulink/components/component.py
@@ -862,7 +862,7 @@ def __init__(self,
         # # MODIFIED 8/14/16 NEW:
         # # PROBLEM: variable has different name for different classes;  need to standardize name across classes
         # try:
-        #     if self.init_status is InitStatus.DEFERRED_INITIALIZATION:
+        #     if self.initialization_status is ContextFlags.DEFERRED_INITIALIZATION:
         #         defer_init = True
         # except AttributeError:
         #     pass
@@ -878,8 +878,8 @@ def __init__(self,
         self.context.source = ContextFlags.COMPONENT
         self.context.string = context + INITIALIZING + ": " + COMPONENT_INIT
 
-        self.init_status = InitStatus.UNSET
-        # self.init_status = InitStatus.INITIALIZING
+        # self.context.initialization_status = ContextFlags.INITIALIZING
+        self.context.initialization_status = ContextFlags.UNSET
 
         defaults = self.ClassDefaults.values().copy()
         if param_defaults is not None:
@@ -1001,7 +1001,7 @@ def __init__(self,
         #    (e.g., instantiate_output_state in Mechanism)
         self._instantiate_attributes_after_function(context=context)
 
-        self.init_status = InitStatus.INITIALIZED
+        self.context.initialization_status = ContextFlags.INITIALIZED
 
     def __repr__(self):
         return '({0} {1})'.format(type(self).__name__, self.name)
@@ -1168,12 +1168,12 @@ def checkAndCastInt(x):
     def _deferred_init(self, context=None):
         """Use in subclasses that require deferred initialization
         """
-        if self.init_status is InitStatus.DEFERRED_INITIALIZATION:
+        if self.context.initialization_status == ContextFlags.DEFERRED_INIT:
 
             # Flag that object is now being initialized
             # Note: self.value will be resolved to the object's value as part of initialization
             #       (usually in _instantiate_function)
-            self.init_status = InitStatus.INITIALIZING
+            self.context.initialization_status = ContextFlags.INITIALIZING
 
             del self.init_args['self']
 
@@ -1206,7 +1206,7 @@ def _deferred_init(self, context=None):
             else:
                 self._assign_default_name()
 
-            self.init_status = InitStatus.INITIALIZED
+            self.context.initialization_status = ContextFlags.INITIALIZED
 
     def _assign_deferred_init_name(self, name, context):
 
@@ -2913,20 +2913,6 @@ def size(self):
             s.append(len(v[i]))
         return np.array(s)
 
-    # @property
-    # def init_status(self):
-    #     try:
-    #         return self._init_status
-    #     except AttributeError:
-    #         return InitStatus.UNSET
-    #
-    # @init_status.setter
-    # def init_status(self, value):
-    #     if not isinstance(value, InitStatus):
-    #         raise ComponentError("PROGRAM ERROR:  Attempt to assign \'init_status\' attribute of {} "
-    #                              "a value ({}) other than one of InitStatus".format(self.name, value))
-    #     self._init_status = value
-
     @property
     def prefs(self):
         # Whenever pref is accessed, use current owner as context (for level checking)
@@ -3078,7 +3064,7 @@ def log(self):
         try:
             return self._log
         except AttributeError:
-            if self.init_status is InitStatus.DEFERRED_INITIALIZATION:
+            if self.context.initialization_status == ContextFlags.DEFERRED_INIT:
                 raise ComponentError("Initialization of {} is deferred; try assigning {} after it is complete "
                                      "or appropriately configuring a system to which it belongs".
                                      format(self.name, 'log'))
diff --git a/psyneulink/components/mechanisms/adaptive/gating/gatingmechanism.py b/psyneulink/components/mechanisms/adaptive/gating/gatingmechanism.py
index 78f7bdb5bf5..843a4be17ff 100644
--- a/psyneulink/components/mechanisms/adaptive/gating/gatingmechanism.py
+++ b/psyneulink/components/mechanisms/adaptive/gating/gatingmechanism.py
@@ -171,6 +171,7 @@
 from psyneulink.components.mechanisms.mechanism import Mechanism_Base
 from psyneulink.components.states.modulatorysignals.gatingsignal import GatingSignal
 from psyneulink.components.states.state import State_Base, _parse_state_spec
+from psyneulink.globals.context import ContextFlags
 from psyneulink.globals.defaults import defaultGatingPolicy
 from psyneulink.globals.keywords import \
     GATING, GATING_POLICY, GATING_PROJECTION, GATING_PROJECTIONS, GATING_SIGNAL, GATING_SIGNALS, GATING_SIGNAL_SPECS, \
@@ -547,7 +548,7 @@ def _assign_as_gating_mechanism(self, context=None):
             for state in mech._input_states + mech._output_states:
                 for projection in state.mod_afferents:
                     # If projection was deferred for init, initialize it now and instantiate for self
-                    if (projection.init_status is InitStatus.DEFERRED_INITIALIZATION
+                    if (projection.context.initialization_status == ContextFlags.DEFERRED_INIT
                         and projection.init_args['sender'] is None):
                         # FIX 5/23/17: MODIFY THIS WHEN (param, GatingProjection) tuple
                         # FIX:         IS REPLACED WITH (param, GatingSignal) tuple
diff --git a/psyneulink/components/mechanisms/adaptive/learning/learningmechanism.py b/psyneulink/components/mechanisms/adaptive/learning/learningmechanism.py
index d22f8c31242..cbd03c3ff75 100644
--- a/psyneulink/components/mechanisms/adaptive/learning/learningmechanism.py
+++ b/psyneulink/components/mechanisms/adaptive/learning/learningmechanism.py
@@ -930,7 +930,8 @@ def __init__(self,
         # delete self.init_args[ERROR_SOURCES]
 
         # # Flag for deferred initialization
-        # self.init_status = InitStatus.DEFERRED_INITIALIZATION
+        # self.context.initialization_status = ContextFlags.DEFERRED_INIT
+        # self.initialization_status = ContextFlags.DEFERRED_INIT
 
         self._learning_rate = learning_rate
 
diff --git a/psyneulink/components/mechanisms/mechanism.py b/psyneulink/components/mechanisms/mechanism.py
index a687f2f55f8..00cd51f21a7 100644
--- a/psyneulink/components/mechanisms/mechanism.py
+++ b/psyneulink/components/mechanisms/mechanism.py
@@ -1433,7 +1433,7 @@ def _handle_arg_input_states(self, input_states):
                 except KeyError:
                     pass
             elif isinstance(parsed_spec, (Projection, Mechanism, State)):
-                if parsed_spec.init_status is InitStatus.DEFERRED_INITIALIZATION:
+                if parsed_spec.context.initialization_status == ContextFlags.DEFERRED_INIT:
                     args = parsed_spec.init_args
                     # MODIFIED 2/21/18 OLD:
                     if REFERENCE_VALUE in args and args[REFERENCE_VALUE] is not None:
@@ -1980,7 +1980,10 @@ def execute(self,
             # These need to be set for states to use as context
             self.context.string = context
             if not INITIALIZING in context: # cxt-set
-                self.context.initialization_status &= ~ContextFlags.INITIALIZING
+                # FIX: 3/31/18 - THIS SHOULD BE MOVED TO END OF __init__ METHOD(S)
+                # self.context.initialization_status &= ~ContextFlags.INITIALIZING
+                # self.context.initialization_status = ContextFlags.INITIALIZED
+
                 if EXECUTING in context:
                     self.context.execution_phase = ContextFlags.PROCESSING
                 if LEARNING in context:
diff --git a/psyneulink/components/mechanisms/processing/objectivemechanism.py b/psyneulink/components/mechanisms/processing/objectivemechanism.py
index 5ad5bfbe5bf..c41bf9b2cb8 100644
--- a/psyneulink/components/mechanisms/processing/objectivemechanism.py
+++ b/psyneulink/components/mechanisms/processing/objectivemechanism.py
@@ -332,6 +332,7 @@
 from psyneulink.components.mechanisms.processing.processingmechanism import ProcessingMechanism_Base
 from psyneulink.components.states.outputstate import OutputState, PRIMARY, standard_output_states
 from psyneulink.components.states.state import _parse_state_spec
+from psyneulink.globals.context import ContextFlags
 from psyneulink.globals.keywords import PARAMS, PROJECTION, PROJECTIONS, CONTROL, DEFAULT_MATRIX, DEFAULT_VARIABLE, \
     EXPONENT, EXPONENTS, FUNCTION, \
     INPUT_STATES, LEARNING, MATRIX, NAME, OBJECTIVE_MECHANISM, SENDER, STATE_TYPE, VARIABLE, WEIGHT, WEIGHTS, \
@@ -657,7 +658,7 @@ def _instantiate_input_states(self, monitored_output_states_specs=None, referenc
         """
         from psyneulink.components.states.inputstate import InputState
         # If call is for initialization
-        if self.init_status is InitStatus.UNSET:
+        if self.context.initialization_status == ContextFlags.UNSET:
             # Use self.input_states (containing specs from **input_states** arg of constructor) or default InputState
             input_states = self.input_states or [{STATE_TYPE: InputState, VARIABLE: [0]}]
             return super()._instantiate_input_states(input_states=input_states, context=context)
@@ -858,7 +859,7 @@ def _instantiate_monitoring_projections(owner,
         if isinstance(sender, OutputState):
             # Projection has been specified for receiver and initialization begun, so call deferred_init()
             if receiver.path_afferents:
-                if not receiver.path_afferents[0].init_status is InitStatus.DEFERRED_INITIALIZATION:
+                if not receiver.path_afferents[0].context.initialization_status == ContextFlags.DEFERRED_INIT:
                     raise ObjectiveMechanismError("PROGRAM ERROR: {} of {} already has an afferent projection "
                                                   "implemented and initialized ({})".
                                                   format(receiver.name, owner.name, receiver.path_afferents[0].name))
diff --git a/psyneulink/components/process.py b/psyneulink/components/process.py
index 6dd6e34357e..3ccfa159f84 100644
--- a/psyneulink/components/process.py
+++ b/psyneulink/components/process.py
@@ -1449,17 +1449,18 @@ def _parse_and_instantiate_projection_entries(self, pathway, context=None):
 
                         # If initialization of MappingProjection has been deferred,
                         #    check sender and receiver, assign them if they have not been assigned, and initialize it
-                        if item.init_status is InitStatus.DEFERRED_INITIALIZATION:
+                        if item.context.initialization_status == ContextFlags.DEFERRED_INIT:
                             # Check sender arg
                             try:
                                 sender_arg = item.init_args[SENDER]
                             except AttributeError:
-                                raise ProcessError("PROGRAM ERROR: init_status of {} is {} but it does not have init_args".
-                                                   format(item, InitStatus.DEFERRED_INITIALIZATION))
+                                raise ProcessError("PROGRAM ERROR: initialization_status of {} is {} "
+                                                   "but it does not have init_args".
+                                                   format(item, ContextFlags.DEFERRED_INIT.name))
                             except KeyError:
-                                raise ProcessError("PROGRAM ERROR: Value of {} is {} "
-                                                   "but init_args does not have entry for {}".
-                                                   format(item.init_args[NAME], InitStatus.DEFERRED_INITIALIZATION, SENDER))
+                                raise ProcessError("PROGRAM ERROR: Value of {} is {} but "
+                                                   "init_args does not have entry for {}".
+                                                   format(item.init_args[NAME],ContextFlags.DEFERRED_INIT.name, SENDER))
                             else:
                                 # If sender is not specified for the Projection,
                                 #    assign mechanism that precedes in pathway
@@ -1475,12 +1476,15 @@ def _parse_and_instantiate_projection_entries(self, pathway, context=None):
                             try:
                                 receiver_arg = item.init_args[kwReceiverArg]
                             except AttributeError:
-                                raise ProcessError("PROGRAM ERROR: init_status of {} is {} but it does not have init_args".
-                                                   format(item, InitStatus.DEFERRED_INITIALIZATION))
+                                raise ProcessError("PROGRAM ERROR: initialization_status of {} is {} "
+                                                   "but it does not have init_args".
+                                                   format(item, ContextFlags.DEFERRED_INIT))
                             except KeyError:
-                                raise ProcessError("PROGRAM ERROR: init_status of {} is {} "
+                                raise ProcessError("PROGRAM ERROR: initialization_status of {} is {} "
                                                    "but init_args does not have entry for {}".
-                                                   format(item.init_args[NAME], InitStatus.DEFERRED_INITIALIZATION, kwReceiverArg))
+                                                   format(item.init_args[NAME],
+                                                          ContextFlags.DEFERRED_INIT,
+                                                          kwReceiverArg))
                             else:
                                 # If receiver is not specified for the Projection,
                                 #    assign mechanism that follows it in the pathway
diff --git a/psyneulink/components/projections/modulatory/controlprojection.py b/psyneulink/components/projections/modulatory/controlprojection.py
index 09014afc501..04406c4a903 100644
--- a/psyneulink/components/projections/modulatory/controlprojection.py
+++ b/psyneulink/components/projections/modulatory/controlprojection.py
@@ -106,6 +106,7 @@
 from psyneulink.components.projections.modulatory.modulatoryprojection import ModulatoryProjection_Base
 from psyneulink.components.projections.projection import ProjectionError, Projection_Base, projection_keywords
 from psyneulink.components.shellclasses import Mechanism, Process_Base
+from psyneulink.globals.context import ContextFlags
 from psyneulink.globals.defaults import defaultControlAllocation
 from psyneulink.globals.keywords import CONTROL, CONTROL_PROJECTION, CONTROL_SIGNAL, PARAMETER_STATE, PROJECTION_SENDER
 from psyneulink.globals.preferences.componentpreferenceset import is_pref_set
@@ -298,10 +299,10 @@ def __init__(self,
                                                   params=params)
 
         # If receiver has not been assigned, defer init to State.instantiate_projection_to_state()
-        if (sender is None or sender.init_status is InitStatus.DEFERRED_INITIALIZATION or
+        if (sender is None or sender.context.initialization_status == ContextFlags.DEFERRED_INIT or
                 inspect.isclass(receiver) or receiver is None or
-                    receiver.init_status is InitStatus.DEFERRED_INITIALIZATION):
-            self.init_status = InitStatus.DEFERRED_INITIALIZATION
+                    receiver.context.initialization_status == ContextFlags.DEFERRED_INIT):
+            self.context.initialization_status = ContextFlags.DEFERRED_INIT
 
         # Validate sender (as variable) and params, and assign to variable and paramInstanceDefaults
         # Note: pass name of mechanism (to override assignment of componentName in super.__init__)
diff --git a/psyneulink/components/projections/modulatory/gatingprojection.py b/psyneulink/components/projections/modulatory/gatingprojection.py
index b5a9ad6a7b9..ccfad42d515 100644
--- a/psyneulink/components/projections/modulatory/gatingprojection.py
+++ b/psyneulink/components/projections/modulatory/gatingprojection.py
@@ -95,6 +95,7 @@
 from psyneulink.components.projections.modulatory.modulatoryprojection import ModulatoryProjection_Base
 from psyneulink.components.projections.projection import ProjectionError, Projection_Base, projection_keywords
 from psyneulink.components.shellclasses import Mechanism, Process_Base
+from psyneulink.globals.context import ContextFlags
 from psyneulink.globals.defaults import defaultGatingPolicy
 from psyneulink.globals.keywords import FUNCTION_OUTPUT_TYPE, GATING, GATING_MECHANISM, GATING_PROJECTION, GATING_SIGNAL, INITIALIZING, INPUT_STATE, OUTPUT_STATE, PROJECTION_SENDER
 from psyneulink.globals.preferences.componentpreferenceset import is_pref_set
@@ -288,7 +289,7 @@ def __init__(self,
         # If receiver has not been assigned, defer init to State.instantiate_projection_to_state()
         if sender is None or receiver is None:
             # Flag for deferred initialization
-            self.init_status = InitStatus.DEFERRED_INITIALIZATION
+            self.context.initialization_status = ContextFlags.DEFERRED_INIT
 
         # Validate sender (as variable) and params, and assign to variable and paramInstanceDefaults
         # Note: pass name of mechanism (to override assignment of componentName in super.__init__)
diff --git a/psyneulink/components/projections/modulatory/learningprojection.py b/psyneulink/components/projections/modulatory/learningprojection.py
index 1bf65ed3785..ff34f5c271b 100644
--- a/psyneulink/components/projections/modulatory/learningprojection.py
+++ b/psyneulink/components/projections/modulatory/learningprojection.py
@@ -450,7 +450,7 @@ def __init__(self,
         # If receiver has not been assigned, defer init to State.instantiate_projection_to_state()
         if sender is None or receiver is None:
             # Flag for deferred initialization
-            self.init_status = InitStatus.DEFERRED_INITIALIZATION
+            self.context.initialization_status = ContextFlags.DEFERRED_INIT
         super().__init__(sender=sender,
                          receiver=receiver,
                          weight=weight,
@@ -617,8 +617,8 @@ def _execute(self, variable, runtime_params=None, context=None):
         runtime_params = runtime_params or {}
 
         # Pass during initialization (since has not yet been fully initialized
-        if self.init_status is InitStatus.DEFERRED_INITIALIZATION:
-            return self.init_status
+        if self.context.initialization_status == ContextFlags.DEFERRED_INIT:
+            return self.context.initialization_status
 
         # if self.learning_rate:
         #     runtime_params.update({SLOPE:self.learning_rate})
diff --git a/psyneulink/components/projections/modulatory/modulatoryprojection.py b/psyneulink/components/projections/modulatory/modulatoryprojection.py
index ed733773b1b..bd7ae813ab9 100644
--- a/psyneulink/components/projections/modulatory/modulatoryprojection.py
+++ b/psyneulink/components/projections/modulatory/modulatoryprojection.py
@@ -229,17 +229,18 @@ def _assign_default_projection_name(self, state=None, sender_name=None, receiver
 
         template = "{} for {}[{}]"
 
-        if self.init_status in {InitStatus.INITIALIZED, InitStatus.INITIALIZING, InitStatus.UNSET}:
+        if self.context.initialization_status &  \
+                (ContextFlags.INITIALIZED | ContextFlags.INITIALIZING | ContextFlags.UNSET):
             # If the name is not a default name for the class, return
             if not self.className + '-' in self.name:
                 return self.name
             self.name = template.format(self.className, self.receiver.owner.name, self.receiver.name)
 
-        elif self.init_status is InitStatus.DEFERRED_INITIALIZATION:
+        elif self.context.initialization_status == ContextFlags.DEFERRED_INIT:
             projection_name = template.format(self.className, state.owner.name, state.name)
             # self.init_args[NAME] = self.init_args[NAME] or projection_name
             self.name = self.init_args[NAME] or projection_name
 
         else:
             raise ModulatoryProjectionError("PROGRAM ERROR: {} has unrecognized InitStatus ({})".
-                                            format(self, self.init_status))
+                                            format(self, ContextFlags._get_context_string(self.context.initialization_status)))
diff --git a/psyneulink/components/projections/pathway/mappingprojection.py b/psyneulink/components/projections/pathway/mappingprojection.py
index 7f5077772f3..8b02c918a1b 100644
--- a/psyneulink/components/projections/pathway/mappingprojection.py
+++ b/psyneulink/components/projections/pathway/mappingprojection.py
@@ -483,7 +483,7 @@ def __init__(self,
 
         # If sender or receiver has not been assigned, defer init to State.instantiate_projection_to_state()
         if sender is None or receiver is None:
-            self.init_status = InitStatus.DEFERRED_INITIALIZATION
+            self.context.initialization_status = ContextFlags.DEFERRED_INIT
 
         # Validate sender (as variable) and params, and assign to variable and paramInstanceDefaults
         super().__init__(sender=sender,
@@ -627,7 +627,8 @@ def _execute(self, variable=None, runtime_params=None, context=None):
 
         # FIX: MOVE THIS TO SUPER
         if EXECUTING in context: # cxt-test
-            self.context.initialization_status &= ~(ContextFlags.VALIDATING | ContextFlags.INITIALIZING)
+            # self.context.initialization_status &= ~(ContextFlags.VALIDATING | ContextFlags.INITIALIZING)
+            # self.context.initialization_status = ContextFlags.INITIALIZED
             self.context.execution_phase = ContextFlags.PROCESSING
             self.context.string = context
 
diff --git a/psyneulink/components/projections/pathway/pathwayprojection.py b/psyneulink/components/projections/pathway/pathwayprojection.py
index a0ae17f372c..4b254b2a418 100644
--- a/psyneulink/components/projections/pathway/pathwayprojection.py
+++ b/psyneulink/components/projections/pathway/pathwayprojection.py
@@ -47,6 +47,7 @@
 
 from psyneulink.components.projections.projection import Projection_Base
 from psyneulink.globals.keywords import PATHWAY_PROJECTION, NAME, SENDER, RECEIVER, CONTEXT
+from psyneulink.globals.context import ContextFlags
 from psyneulink.components.component import InitStatus
 
 __all__ = []
@@ -94,7 +95,7 @@ def _assign_default_projection_name(self, state=None, sender_name=None, receiver
         name_template = "{}[{}]"
         projection_name_template = "{} from {} to {}"
 
-        if self.init_status is InitStatus.DEFERRED_INITIALIZATION:
+        if self.context.initialization_status == ContextFlags.DEFERRED_INIT:
             if self.init_args[SENDER]:
                 sender = self.init_args[SENDER]
                 if isinstance(sender, type):
@@ -113,7 +114,7 @@ def _assign_default_projection_name(self, state=None, sender_name=None, receiver
         elif not self.className + '-' in self.name:
             return self.name
 
-        elif self.init_status is InitStatus.INITIALIZED:
+        elif self.context.initialization_status == ContextFlags.INITIALIZED:
             if self.sender.owner:
                 sender_name = name_template.format(self.sender.owner.name, self.sender.name)
             if self.receiver.owner:
@@ -122,4 +123,6 @@ def _assign_default_projection_name(self, state=None, sender_name=None, receiver
 
         else:
             raise PathwayProjectionError("PROGRAM ERROR: {} has unrecognized InitStatus ({})".
-                                            format(self, self.init_status))
+                                            format(self,
+                                                   ContextFlags._get_context_string(
+                                                           self.context.initialization_status)))
diff --git a/psyneulink/components/projections/projection.py b/psyneulink/components/projections/projection.py
index cee7d24bb3f..8fcfd8abbb9 100644
--- a/psyneulink/components/projections/projection.py
+++ b/psyneulink/components/projections/projection.py
@@ -659,22 +659,16 @@ def __init__(self,
                                                   exponent=exponent,
                                                   params=params)
 
-        try:
-            if self.init_status is InitStatus.DEFERRED_INITIALIZATION:
-                self._assign_deferred_init_name(name, context)
-                self.init_args = locals().copy()
-                self.init_args[CONTEXT] = self
-                self.init_args[NAME] = name
-
-                # remove local imports
-                del self.init_args['ParameterState']
-                del self.init_args['State_Base']
-                return
-        except AttributeError:
-            # if this Projection does not have an init_status attribute, we can guarantee that it's not in
-            # deferred init state. It's tricky to ensure this attribute always exists due to the nature
-            # of deferred init
-            pass
+        if self.context.initialization_status == ContextFlags.DEFERRED_INIT:
+            self._assign_deferred_init_name(name, context)
+            self.init_args = locals().copy()
+            self.init_args[CONTEXT] = self
+            self.init_args[NAME] = name
+
+            # remove local imports
+            del self.init_args['ParameterState']
+            del self.init_args['State_Base']
+            return
 
         self.receiver = receiver
 
@@ -903,7 +897,7 @@ def _execute(self, variable, runtime_params=None, context=None):
     @property
     def socket_assignments(self):
 
-        if self.init_status is InitStatus.DEFERRED_INITIALIZATION:
+        if self.context.initialization_status == ContextFlags.DEFERRED_INIT:
             sender = self.init_args[SENDER]
             receiver = self.init_args[RECEIVER]
         else:
@@ -1074,7 +1068,7 @@ def _parse_projection_spec(projection_spec,
                                   "between Projection and ProjectionTuple")
         projection._weight = proj_spec_dict[WEIGHT] or projection.weight
         projection._exponent = proj_spec_dict[EXPONENT] or projection.exponent
-        if projection.init_status is InitStatus.DEFERRED_INITIALIZATION:
+        if projection.context.initialization_status == ContextFlags.DEFERRED_INIT:
             projection.init_args[NAME] = proj_spec_dict[NAME] or projection.init_args[NAME]
         else:
             projection.name = proj_spec_dict[NAME] or projection.name
@@ -1648,7 +1642,7 @@ def _validate_projection_type(projection_class):
     if isinstance(projection_spec, Projection):
 
         # It is in deferred_init status
-        if projection_spec.init_status is InitStatus.DEFERRED_INITIALIZATION:
+        if projection_spec.context.initialization_status == ContextFlags.DEFERRED_INIT:
 
             # Try to get the State to which the Projection will be connected when fully initialized
             #     as confirmation that it is the correct type for state_type
@@ -1769,7 +1763,7 @@ def _validate_receiver(sender_mech:Mechanism,
     """
     spec_type = " in the {} arg ".format(spec_type) or ""
 
-    if projection.init_status is InitStatus.DEFERRED_INITIALIZATION:
+    if projection.context.initialization_status == ContextFlags.DEFERRED_INIT:
         # receiver = projection.init_args['receiver'].owner
         state = projection.init_args['receiver']
         receiver = state.owner
diff --git a/psyneulink/components/states/inputstate.py b/psyneulink/components/states/inputstate.py
index 0ed4e01011f..8e7d2de0e5c 100644
--- a/psyneulink/components/states/inputstate.py
+++ b/psyneulink/components/states/inputstate.py
@@ -741,7 +741,7 @@ def __init__(self,
             self.init_args['projections'] = projections
 
             # Flag for deferred initialization
-            self.init_status = InitStatus.DEFERRED_INITIALIZATION
+            self.context.initialization_status = ContextFlags.DEFERRED_INIT
             return
 
         self.reference_value = reference_value
@@ -1000,7 +1000,7 @@ def _parse_state_specific_specs(self, owner, state_dict, state_specific_spec):
                             try:
                                 sender_dim = projection_spec.state.value.ndim
                             except AttributeError:
-                                if projection_spec.state.init_status is InitStatus.DEFERRED_INITIALIZATION:
+                                if projection_spec.state.context.initialization_status == ContextFlags.DEFERRED_INIT:
                                     continue
                                 else:
                                     raise StateError("PROGRAM ERROR: indeterminate value for {} "
@@ -1021,7 +1021,7 @@ def _parse_state_specific_specs(self, owner, state_dict, state_specific_spec):
                                     matrix = None
                                 # MODIFIED 11/25/17 END
                             elif isinstance(projection, Projection):
-                                if projection.init_status is InitStatus.DEFERRED_INITIALIZATION:
+                                if projection.context.initialization_status == ContextFlags.DEFERRED_INIT:
                                     continue
                                 matrix = projection.matrix
                             else:
diff --git a/psyneulink/components/states/modulatorysignals/controlsignal.py b/psyneulink/components/states/modulatorysignals/controlsignal.py
index 3506ac6065c..5b1476a18c6 100644
--- a/psyneulink/components/states/modulatorysignals/controlsignal.py
+++ b/psyneulink/components/states/modulatorysignals/controlsignal.py
@@ -306,11 +306,11 @@
 from psyneulink.components.states.modulatorysignals.modulatorysignal import ModulatorySignal
 from psyneulink.components.states.outputstate import SEQUENTIAL
 from psyneulink.components.states.state import State_Base
+from psyneulink.globals.context import ContextFlags
 from psyneulink.globals.defaults import defaultControlAllocation
 from psyneulink.globals.keywords import ALLOCATION_SAMPLES, AUTO, COMMAND_LINE, CONTROLLED_PARAMS, CONTROL_PROJECTION, CONTROL_SIGNAL, EXECUTING, FUNCTION, FUNCTION_PARAMS, INTERCEPT, OFF, ON, OUTPUT_STATE_PARAMS, PARAMETER_STATE, PARAMETER_STATES, PROJECTION_TYPE, RECEIVER, SEPARATOR_BAR, SLOPE, SUM, kwAssign
 from psyneulink.globals.preferences.componentpreferenceset import is_pref_set
 from psyneulink.globals.preferences.preferenceset import PreferenceLevel
-from psyneulink.globals.context import ContextFlags
 from psyneulink.globals.utilities import is_numeric, iscompatible, kwCompatibilityLength, kwCompatibilityNumeric, kwCompatibilityType
 
 __all__ = [
@@ -729,7 +729,7 @@ def __init__(self,
                          context=context)
 
         # Default cost params
-        if self.init_status is not InitStatus.DEFERRED_INITIALIZATION:
+        if self.context.initialization_status != ContextFlags.DEFERRED_INIT:
             self.intensity_cost = self.intensity_cost_function(self.instance_defaults.allocation)
         else:
             self.intensity_cost = self.intensity_cost_function(self.ClassDefaults.allocation)
@@ -1186,7 +1186,7 @@ def get_costs(self):
     @property
     def value(self):
         # In case the ControlSignal has not yet been assigned (and its value is INITIALIZING or DEFERRED_INITIALIZATION
-        if self.init_status in {InitStatus.DEFERRED_INITIALIZATION, InitStatus.INITIALIZING}:
+        if self.context.initialization_status & (ContextFlags.DEFERRED_INIT | ContextFlags.INITIALIZING):
             return None
         else:
             return self._value
diff --git a/psyneulink/components/states/modulatorysignals/modulatorysignal.py b/psyneulink/components/states/modulatorysignals/modulatorysignal.py
index 4a4cc9aa265..ba4bb583007 100644
--- a/psyneulink/components/states/modulatorysignals/modulatorysignal.py
+++ b/psyneulink/components/states/modulatorysignals/modulatorysignal.py
@@ -209,6 +209,7 @@
 from psyneulink.components.shellclasses import Mechanism, State
 from psyneulink.components.states.outputstate import OutputState
 from psyneulink.components.states.state import StateError, State_Base
+from psyneulink.globals.context import ContextFlags
 from psyneulink.globals.keywords import MECHANISM, MODULATION, MODULATORY_SIGNAL, PROJECTIONS
 from psyneulink.globals.preferences.preferenceset import PreferenceLevel
 
@@ -401,16 +402,16 @@ def __init__(self,
                  context=None):
 
         # Deferred initialization
-        try:
-            if self.init_status in {InitStatus.DEFERRED_INITIALIZATION, InitStatus.INITIALIZING}:
-                # If init was deferred, it may have been because owner was not yet known (see OutputState.__init__),
-                #   and so modulation hasn't had a chance to be assigned to the owner's value
-                #   (i.e., if it was not specified in the constructor), so do it now;
-                #   however modulation has already been assigned to params, so need to assign it there
-                params[MODULATION] = self.modulation or owner.modulation
+        # if self.context.initialization_status & (ContextFlags.DEFERRED_INIT | ContextFlags.INITIALIZING):
+        if self.context.initialization_status & ContextFlags.DEFERRED_INIT:
+            # If init was deferred, it may have been because owner was not yet known (see OutputState.__init__),
+            #   and so modulation hasn't had a chance to be assigned to the owner's value
+            #   (i.e., if it was not specified in the constructor), so do it now;
+            #   however modulation has already been assigned to params, so need to assign it there
+            params[MODULATION] = self.modulation or owner.modulation
 
         # Standard initialization
-        except AttributeError:
+        else:
             # Assign args to params and functionParams dicts (kwConstants must == arg names)
             params = self._assign_args_to_param_dicts(params=params,
                                                       modulation=modulation)
@@ -427,7 +428,7 @@ def __init__(self,
                          prefs=prefs,
                          context=context)
 
-        if self.init_status is InitStatus.INITIALIZED:
+        if self.context.initialization_status == ContextFlags.INITIALIZED:
             self._assign_default_state_name(context=context)
 
     def _instantiate_attributes_after_function(self, context=None):
diff --git a/psyneulink/components/states/outputstate.py b/psyneulink/components/states/outputstate.py
index a58a5eabd84..a3a6925332e 100644
--- a/psyneulink/components/states/outputstate.py
+++ b/psyneulink/components/states/outputstate.py
@@ -920,7 +920,7 @@ def __init__(self,
             self.init_args['projections'] = projections
 
             # Flag for deferred initialization
-            self.init_status = InitStatus.DEFERRED_INITIALIZATION
+            self.context.initialization_status = ContextFlags.DEFERRED_INIT
             return
 
         self.reference_value = reference_value
@@ -1345,7 +1345,7 @@ def _instantiate_output_states(owner, output_states=None, context=None):
 
             # OutputState object
             if isinstance(output_state, OutputState):
-                if output_state.init_status is InitStatus.DEFERRED_INITIALIZATION:
+                if output_state.context.initialization_status == ContextFlags.DEFERRED_INIT:
                     try:
                         output_state_value = OutputState._get_state_function_value(owner,
                                                                                    output_state.function,
diff --git a/psyneulink/components/states/parameterstate.py b/psyneulink/components/states/parameterstate.py
index e58f072379b..a0632229103 100644
--- a/psyneulink/components/states/parameterstate.py
+++ b/psyneulink/components/states/parameterstate.py
@@ -363,6 +363,7 @@
 from psyneulink.components.states.modulatorysignals.modulatorysignal import ModulatorySignal
 from psyneulink.components.states.state import StateError, State_Base, _instantiate_state, state_type_keywords
 from psyneulink.globals.keywords import CONTROL_PROJECTION, CONTROL_SIGNAL, CONTROL_SIGNALS, FUNCTION, FUNCTION_PARAMS, LEARNING_SIGNAL, LEARNING_SIGNALS, MECHANISM, NAME, PARAMETER_STATE, PARAMETER_STATES, PARAMETER_STATE_PARAMS, PATHWAY_PROJECTION, PROJECTION, PROJECTIONS, PROJECTION_TYPE, REFERENCE_VALUE, SENDER, VALUE
+from psyneulink.globals.context import ContextFlags
 from psyneulink.globals.preferences.componentpreferenceset import is_pref_set
 from psyneulink.globals.preferences.preferenceset import PreferenceLevel
 from psyneulink.globals.utilities \
@@ -794,7 +795,7 @@ def _parse_state_specific_specs(self, owner, state_dict, state_specific_spec):
                                                                      ControlProjection.__name__,
                                                                      LearningProjection.__name__,
                                                                      mod_projection, state_dict[NAME], owner.name))
-                                elif mod_projection.init_status is InitStatus.DEFERRED_INITIALIZATION:
+                                elif mod_projection.context.initialization_status == ContextFlags.DEFERRED_INIT:
                                     continue
                                 mod_proj_value = mod_projection.value
                             else:
diff --git a/psyneulink/components/states/state.py b/psyneulink/components/states/state.py
index 4c615c9b90c..59463a01e59 100644
--- a/psyneulink/components/states/state.py
+++ b/psyneulink/components/states/state.py
@@ -737,6 +737,7 @@ def test_multiple_modulatory_projections_with_mech_and_state_name_specs(self):
 from psyneulink.globals.preferences.componentpreferenceset import kpVerbosePref
 from psyneulink.globals.preferences.preferenceset import PreferenceLevel
 from psyneulink.globals.registry import register_category
+from psyneulink.globals.context import ContextFlags
 from psyneulink.globals.utilities import ContentAddressableList, MODULATION_OVERRIDE, Modulation, convert_to_np_array, get_args, get_class_attributes, is_numeric, is_value_spec, iscompatible, merge_param_dicts, type_match
 from psyneulink.scheduling.time import TimeScale
 
@@ -1400,7 +1401,7 @@ def _instantiate_projections_to_state(self, projections, context=None):
             # ASSIGN PARAMS
 
             # Deferred init
-            if projection.init_status is InitStatus.DEFERRED_INITIALIZATION:
+            if projection.context.initialization_status == ContextFlags.DEFERRED_INIT:
 
                 proj_sender = projection.init_args[SENDER]
                 proj_receiver = projection.init_args[RECEIVER]
@@ -1441,7 +1442,7 @@ def _instantiate_projections_to_state(self, projections, context=None):
 
                 # Construct and assign name
                 if isinstance(sender, State):
-                    if sender.init_status is InitStatus.DEFERRED_INITIALIZATION:
+                    if sender.context.initialization_status == ContextFlags.DEFERRED_INIT:
                         sender_name = sender.init_args[NAME]
                     else:
                         sender_name = sender.name
@@ -1457,13 +1458,13 @@ def _instantiate_projections_to_state(self, projections, context=None):
 
                 # If sender has been instantiated, try to complete initialization
                 # If not, assume it will be handled later (by Mechanism or Composition)
-                if isinstance(sender, State) and sender.init_status is InitStatus.INITIALIZED:
+                if isinstance(sender, State) and sender.context.initialization_status == ContextFlags.INITIALIZED:
                     projection._deferred_init()
 
 
             # VALIDATE (if initialized)
 
-            if projection.init_status is InitStatus.INITIALIZED:
+            if projection.context.initialization_status == ContextFlags.INITIALIZED:
 
                 # FIX: 10/3/17 - VERIFY THE FOLLOWING:
                 # IMPLEMENTATION NOTE:
@@ -1648,7 +1649,7 @@ def _get_receiver_state(spec):
                 projection = projection_spec
                 projection_type = projection.__class__
 
-                if projection.init_status is InitStatus.DEFERRED_INITIALIZATION:
+                if projection.context.initialization_status == ContextFlags.DEFERRED_INIT:
                     projection.init_args[RECEIVER] = projection.init_args[RECEIVER] or receiver
                     proj_recvr = projection.init_args[RECEIVER]
                 else:
@@ -1695,13 +1696,13 @@ def _get_receiver_state(spec):
             # ASSIGN REMAINING PARAMS
 
             # Deferred init
-            if projection.init_status is InitStatus.DEFERRED_INITIALIZATION:
+            if projection.context.initialization_status == ContextFlags.DEFERRED_INIT:
 
                 projection.init_args[SENDER] = self
 
                 # Construct and assign name
                 if isinstance(receiver, State):
-                    if receiver.init_status is InitStatus.DEFERRED_INITIALIZATION:
+                    if receiver.context.initialization_status == ContextFlags.DEFERRED_INIT:
                         receiver_name = receiver.init_args[NAME]
                     else:
                         receiver_name = receiver.name
@@ -1727,15 +1728,16 @@ def _get_receiver_state(spec):
 
                 # If receiver has been instantiated, try to complete initialization
                 # If not, assume it will be handled later (by Mechanism or Composition)
-                if isinstance(receiver, State) and receiver.init_status is InitStatus.INITIALIZED:
+                if isinstance(receiver, State) and receiver.context.initialization_status == ContextFlags.INITIALIZED:
                     projection._deferred_init()
 
             # VALIDATE (if initialized or being initialized (UNSET))
 
-            if projection.init_status in {InitStatus.INITIALIZED, InitStatus.INITIALIZING, InitStatus.UNSET}:
+            if projection.context.initialization_status & \
+                    (ContextFlags.INITIALIZED | ContextFlags.INITIALIZING | ContextFlags.UNSET):
 
                 # If still being initialized, then assign sender and receiver as necessary
-                if projection.init_status in {InitStatus.INITIALIZING, InitStatus.UNSET}:
+                if projection.context.initialization_status & (ContextFlags.INITIALIZING | ContextFlags.UNSET):
                     if not isinstance(projection.sender, State):
                         projection.sender = self
 
@@ -1935,7 +1937,7 @@ def update(self, params=None, context=None):
                                                       context=context) # cxt-pass cxt-push
 
             # If this is initialization run and projection initialization has been deferred, pass
-            if INITIALIZING in context and projection.init_status is InitStatus.DEFERRED_INITIALIZATION: # cxt-test
+            if INITIALIZING in context and projection.context.initialization_status == ContextFlags.DEFERRED_INIT: # cxt-test
                 continue
 
             if isinstance(projection, PathwayProjection_Base):
@@ -2153,7 +2155,7 @@ def _instantiate_state_list(owner,
         # default_name = state._assign_default_state_name()
         # if default_name:
         #      state_name = default_name
-        # elif state.init_status is InitStatus.DEFERRED_INITIALIZATION:
+        # elif state.initialization_status is ContextFlags.DEFERRED_INIT
         #     state_name = state.init_args[NAME]
         # else:
         #     state_name = state.name
@@ -2243,7 +2245,7 @@ def _instantiate_state(state_type:_is_state_class,           # State's type
         # State initialization was deferred (owner or reference_value was missing), so
         #    assign owner, variable, and/or reference_value
         #    if they were not specified in call to _instantiate_state
-        if state.init_status is InitStatus.DEFERRED_INITIALIZATION:
+        if state.context.initialization_status == ContextFlags.DEFERRED_INIT:
             if not state.init_args[OWNER]:
                 state.init_args[OWNER] = owner
             if not VARIABLE in state.init_args or state.init_args[VARIABLE] is None:
@@ -2543,7 +2545,7 @@ def _parse_state_spec(state_type=None,
         #    so assume it is a reference to the State itself that is being (or has been) instantiated
         elif isinstance(state_specification, state_type):
             # Make sure that the specified State belongs to the Mechanism passed in the owner arg
-            if state_specification.init_status is InitStatus.DEFERRED_INITIALIZATION:
+            if state_specification.context.initialization_status == ContextFlags.DEFERRED_INIT:
                 state_owner = state_specification.init_args[OWNER]
             else:
                 state_owner = state_specification.owner
@@ -2601,7 +2603,7 @@ def _parse_state_spec(state_type=None,
 
         # Projection has been instantiated
         if isinstance(projection_spec, Projection):
-            if projection_spec.init_status is InitStatus.INITIALIZED:
+            if projection_spec.context.initialization_status == ContextFlags.INITIALIZED:
                 projection_value = projection_spec.value
             # If deferred_init, need to get sender and matrix to determine value
             else:
diff --git a/psyneulink/components/system.py b/psyneulink/components/system.py
index 2ab2dbd787b..f23e5808eae 100644
--- a/psyneulink/components/system.py
+++ b/psyneulink/components/system.py
@@ -2437,7 +2437,7 @@ def _get_control_signals_for_system(self, control_signals=None, context=None):
             for parameter_state in mech._parameter_states:
                 for projection in parameter_state.mod_afferents:
                     # If Projection was deferred for init, instantiate its ControlSignal and then initialize it
-                    if projection.init_status is InitStatus.DEFERRED_INITIALIZATION:
+                    if projection.context.initialization_status == ContextFlags.DEFERRED_INIT:
                         proj_control_signal_specs = projection.control_signal_params or {}
                         proj_control_signal_specs.update({PROJECTIONS: [projection]})
                         control_signal_specs.append(proj_control_signal_specs)
diff --git a/psyneulink/globals/context.py b/psyneulink/globals/context.py
index d52790a245e..108cd100a36 100644
--- a/psyneulink/globals/context.py
+++ b/psyneulink/globals/context.py
@@ -40,28 +40,6 @@ class ContextFlags(IntEnum):
     Also used to specify the context in which a value of the Component or its attribute is `logged <Log_Conditions>`.
     """
 
-    # INITIALIZATION = 1<<1  # 2
-    # """Set during execution of the Component's constructor."""
-    # VALIDATION =     1<<2  # 4
-    # """Set during validation of the value of a Component or its attribute."""
-    # EXECUTION =      1<<3  # 8
-    # """Set during any execution of the Component."""
-    # PROCESSING =     1<<4  # 16
-    # """Set during the `processing phase <System_Execution_Processing>` of execution of a Composition."""
-    # LEARNING =       1<<5  # 32
-    # """Set during the `learning phase <System_Execution_Learning>` of execution of a Composition."""
-    # CONTROL =        1<<6  # 64
-    # """Set during the `control phase System_Execution_Control>` of execution of a Composition."""
-    # TRIAL =          1<<7  # 128
-    # """Set at the end of a `TRIAL`."""
-    # RUN =            1<<8  # 256
-    # """Set at the end of a `RUN`."""
-    # SIMULATION =     1<<9  # 512
-    # # Set during simulation by Composition.controller
-    # COMMAND_LINE =   1<<10 # 1024
-    # # Component accessed by user
-    # CONSTRUCTOR =    1<<11 # 2048
-
     UNSET = 0
 
     DEFERRED_INIT = 1<<1  # 2
diff --git a/psyneulink/globals/environment.py b/psyneulink/globals/environment.py
index 7e1e0718da3..cf0af056111 100644
--- a/psyneulink/globals/environment.py
+++ b/psyneulink/globals/environment.py
@@ -758,7 +758,8 @@ def run(object,
             if RUN in context and not EVC_SIMULATION in context: # cxt-test
                 context = RUN + ": EXECUTING " + object_type.upper() + " " + object.name # cxt-done ? cxt-pass
                 # FIX: 3/30/18:  SHOULDN'T NEED THIS IF ContextFlags.INITIALIZED GETS SET AT END OF INITIALIZATION
-                object.context.initialization_status &= ~(ContextFlags.VALIDATING | ContextFlags.INITIALIZING)
+                # object.context.initialization_status &= ~(ContextFlags.VALIDATING | ContextFlags.INITIALIZING)
+                # object.context.initialization_status = ContextFlags.INITIALIZED
                 object.context.execution_phase = ContextFlags.EXECUTING
                 object.context.string = RUN + ": EXECUTING " + object_type.upper() + " " + object.name
             result = object.execute(
diff --git a/psyneulink/globals/log.py b/psyneulink/globals/log.py
index 0b3735ebb20..c6e5d771e91 100644
--- a/psyneulink/globals/log.py
+++ b/psyneulink/globals/log.py
@@ -412,7 +412,8 @@ class LogCondition(IntEnum):
     """
     OFF = ContextFlags.UNSET
     # """No recording."""
-    INITIALIZATION = ContextFlags.INITIALIZING
+    # INITIALIZATION = ContextFlags.INITIALIZING
+    INITIALIZATION = ContextFlags.INITIALIZED
     """Set during execution of the Component's constructor."""
     VALIDATION =  ContextFlags.VALIDATING
     """Set during validation of the value of a Component or its attribute."""
diff --git a/psyneulink/library/mechanisms/adaptive/learning/autoassociativelearningmechanism.py b/psyneulink/library/mechanisms/adaptive/learning/autoassociativelearningmechanism.py
index d7c0e69e078..fee4d33faf3 100644
--- a/psyneulink/library/mechanisms/adaptive/learning/autoassociativelearningmechanism.py
+++ b/psyneulink/library/mechanisms/adaptive/learning/autoassociativelearningmechanism.py
@@ -313,7 +313,8 @@ def __init__(self,
         # self.init_args['name'] = name
 
         # # Flag for deferred initialization
-        # self.init_status = InitStatus.DEFERRED_INITIALIZATION
+        # self.context.initialization_status = ContextFlags.DEFERRED_INIT
+        # self.initialization_status = ContextFlags.DEFERRED_INIT
 
         # self._learning_rate = learning_rate
 
diff --git a/tests/log/test_log.py b/tests/log/test_log.py
index 0ad85fe0559..9b2024fb191 100644
--- a/tests/log/test_log.py
+++ b/tests/log/test_log.py
@@ -100,7 +100,7 @@ def test_log(self):
 
     def test_log_initialization(self):
         T = pnl.TransferMechanism(
-                prefs={pnl.LOG_PREF: pnl.PreferenceEntry(pnl.ContextFlags.INITIALIZING, pnl.PreferenceLevel.INSTANCE)}
+                prefs={pnl.LOG_PREF: pnl.PreferenceEntry(pnl.LogCondition.INITIALIZATION, pnl.PreferenceLevel.INSTANCE)}
         )
         assert T.logged_items == {'value': 'INITIALIZATION'}