Given what kind of history may have been in the undo files, has already disappeared (the only thing I can think of that can give an indication), I think the only way to narrow it down to a specific revision is the brute force approach.
If the range of possible revisions is a little large, and making changes to the building in size or another non-flying aspect, linear or close to linear, you can use bisect to basically perform a binary search to narrow down which revision you are looking for (or maybe just get closer to her). For every revision that bisect stops testing, you should build this revision and test any aspect that you use to compare with what was planned for that night. May not even require construction, depending on the test.
If it is really as simple as the graph you are depicting and the range of possibilities is short, you can simply start with the latest version, which it may be, and go back a few changes by testing the original assembly.
As for the final test comparing two assemblies, hashing of the test assembly and comparing it with the hash of the original assembly may work. If compiling the assembly machine on the night machine and compiling the same revision on your machine does not create binary identical assemblies, you may need to use binary differences (for example, with xdelta or bsdiff ) and find the smallest diff.
Mercurial does not have the necessary information:
Mercurial does not make a journal from its article and monitors all actions performed in relation to the repository, such as push , pull , update . If this were so, it would create a lot of registration information. It makes hooks available that you can use to do this if you wish.
It also doesn’t matter what you do with the contents of the working directory, for example, opening files or compiling, so of course it will not track this at all. This is simply not what Mercurial does.
It was a mistake not to know exactly how the planned assembly was built. You agree implicitly, because now you are registering this very information. The lack of this information earlier simply returned you to bite you, and there is no easy way out of this. Mercurial does not have the necessary information. If the central repo is only a shared directory, and not a repository hosted on the Internet that can track activity, the only information about what was built is in the compiled version. Whether this is some metadata declared in the source that becomes part of the assembly, a naive aspect like file size, or are you really stuck hashing files, you cannot get the answer without any effort.
You may not need to check every revision; there may be changes that you can be sure are not candidates. Knowing compilation time is simply a factor as the upper limit of the test revision range. You know that changes after this time could not be candidates. What you do not know is what was pressed on the server at the time the build server pulled it out. But you know that changes from this day are most likely. You also know that changes in parallel unnamed branches are less likely candidates than linear changes and merges. If there are many parallel unnamed branches, and you know that all your developers merge in a certain way, you can know if revisions should be tested under parent1 or parent2.
You may not even need to compile if there is metadata that you can parse from the source code to compare with what you know about a particular assembly.
And you can automate the search. It would be easier to do this with linear search: less heuristics for design.
The bottom line is that Mercurial does not have a magic button to help in this case.