anchor.diff:        ;; Calculate list of library-versions involved
         (let ((library-versions-involved
                (calculate-library-versions-involved library-version)))
  -	
  +
           ;; Validate the library versions list
                                           ;(validate-library-versions-list library-versions)
   
  
positive.code:                     (error "Couldn't find a cld for ~S library~%" library-name))))))))
  
  (defmethod load-project ((directory pathname)
  			 &key
  			   version
  			   libraries-directory
  			   (verbose *verbose-mode*)
  			   (solving-mode *solving-mode*)
  			   (clean-asdf-environment *clean-asdf-environment*))
    (load-project (load-project-from-directory directory)
  		:version version
  		:libraries-directory libraries-directory
  		:verbose verbose
  		:solving-mode solving-mode
  		:clean-asdf-environment clean-asdf-environment))
  
  (defmethod load-project ((project project)
  			 &key
  			   version
  			   libraries-directory
  			   (verbose *verbose-mode*)
  			   (solving-mode *solving-mode*)
  			   (clean-asdf-environment *clean-asdf-environment*))
    "Install a project dependencies and load the project in the current lisp image"
  
    (install-project project
  
negative.code:                (loop for library-version in library-versions
                    do (load-library-version library-version :if-already-loaded if-already-loaded))))
             (load-dependency-cld (dependency)
  	     ; To load a dependency cld, we try looking in repositories first, and, if we couldn't find
               ; a cld there, we try to load the cld specified in the dependency. This is so that we can give
               ; the user an opportunity to have some control of which cld files he wants to take priority over others
               ; by adding a cld repository to *cld-repositories*
  	     (let (cld)
  	       (loop
  		  for cld-repository in (list-cld-repositories)
  		  while (not cld)
  		  do
  		    (let ((repository-cld (find-cld cld-repository
  						    (library-name dependency))))
  		      (setf cld (and repository-cld (load-cld repository-cld
  							      :if-already-loaded
  							      if-already-loaded)))
  		      (when cld
  			(verbose-msg "~A cld found in ~A~%"
  				     (library-name dependency)
  				     cld-repository))))
  	       (if cld
  		   ;; A cld was found in repositories, load it
  		   (load-dependency dependency)
  		   ;; Otherwise, a cld could not be found in repositories, try with the dependency cld, if it exists
  		   (progn
  		     (setf cld (and (cld dependency)
  				    (load-cld (cld dependency)
  					      :if-already-loaded if-already-loaded)))
  		     (if cld
  			 ;; the cld specified in the dependency was found, load the dependency
  			 (load-dependency dependency)
  			 
  		       ;; else, In this case a cld was not found either in repositories or by looking at the cld
  		       ;; specified in the dependency
  		       ;; What to do in this case??
  		       ;; we can signal an error, or ignore this (signal a warning), as
  		       ;; the library version may be loadable from the user system repository
  		       ;; anyway (.i.e. Quicklisp)
  		       (ecase *solving-mode*
  			 (:lenient (warn "Couldn't find a cld for ~A" dependency))
  			 (:strict (error "Couldn't find a cld for ~A" dependency)))))))))
      ;; Load the dependencies for the library version
      (loop for dependency in (dependencies library-version)
         do (progn
              (verbose-msg "Handling ~A.~%" dependency)
              ;; For each dependency, try to load its cld
              (load-dependency-cld dependency)))))
  
  (defun calculate-library-versions-involved (library-version &optional visited)
    (remove-duplicates
  