Evaluating Parser State
If I understand the rules correctly, the last rule "Otherwise return the state of the most advanced non-ready module." isn't met by your method. Having states {ParserState.LoadingReference, ParserState.Parsed, ParserState.Parsing, ParserState.Ready} I would expect the returned state equals to ParserState.Parsed but your method results in ParserState.Parsing.  
The rules 3 and 4 are superflous because they are satisfied by rule 1.
Because any error state takes precedence over every other state you should chewck this first. If all states are of the same error state it will result in the same result, but checking first the error states will be faster.  
this  

if (result == ParserState.Ready &amp;&amp; moduleStates.Any(item =&gt; item != ParserState.Ready))
{
    result = moduleStates.Except(new[] {ParserState.Ready}).Max();
}  


looks strange. result equals to the Min() of the modulStates, so let us assume it would equal to ParserState.Ready then it is garanteed that the second condition will result in true because you already checked if all states are the same.  Because of the the check of the same values the second condition of Debug.Assert(result != ParserState.Ready || moduleStates.All(item =&gt; item == ParserState.Ready)); is superflous as well.  
You should use the same variables name for the same type when using lambdas. One time you have ps =&gt; ps == value and the other times you use ms =&gt; ms == ParserState.Error.  
The method relies on a class variable which I would change. Add a parameter to that method declaration so it can stand on its own.  


Implementing the mentioned points will lead to  

private ParserState EvaluateParserState(IList&lt;ParserState&gt; moduleStates)
{
    // error state takes precedence over every other state
    if (moduleStates.Any(ms =&gt; ms == ParserState.Error))
    {
        Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", ParserState.Error,
        Thread.CurrentThread.ManagedThreadId);
        return ParserState.Error;
    }
    if (moduleStates.Any(ms =&gt; ms == ParserState.ResolverError))
    {
        Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", ParserState.ResolverError,
        Thread.CurrentThread.ManagedThreadId);
        return ParserState.ResolverError;
    }

    var state = States.SingleOrDefault(value =&gt; moduleStates.All(ms =&gt; ms == value));

    if (state != default(ParserState))
    {
        // if all modules are in the same state, we have our result.
        Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", state, Thread.CurrentThread.ManagedThreadId);
        return state;
    }

    var result = moduleStates.Except(new[] { ParserState.Ready }).Max();

    Debug.Assert(result != ParserState.Ready);

    Debug.WriteLine("ParserState evaluates to '{0}' (thread {1})", result,
    Thread.CurrentThread.ManagedThreadId);
    return result;
}