OspreySharp: close C# Stage 7 algorithmic gap + port Rust v2 reconciliation envelope + parity-sprint perf work

pwiz_tools/OspreySharp/OspreySharp.Core/OspreyConfig.cs

@@ -387,6 +387,33 @@ internal static string EscapeForRustDebug(string s)
         /// hash invariant to invocation order).
         /// </summary>
         public string ReconciliationParameterHash()
+        {
+            var stems = new List<string>(InputFiles?.Count ?? 0);
+            if (InputFiles != null)
+            {
+                foreach (var path in InputFiles)
+                {
+                    string stem = Path.GetFileNameWithoutExtension(path);
+                    if (!string.IsNullOrEmpty(stem))
+                        stems.Add(stem);
+                }
+            }
+            return ReconciliationParameterHashForStems(stems);
+        }
+
+        /// <summary>
+        /// Compute the reconciliation parameter hash for an explicit set of
+        /// file stems. Used by per-file Stage 6 rescore workers, whose
+        /// <see cref="InputFiles"/> only carries this worker's single
+        /// parquet — the hash that the downstream <c>--join-at-pass=2</c>
+        /// merge node expects is computed over ALL files in the join, so
+        /// the worker must read the full set from the planner's
+        /// <c>reconciliation.json</c> envelope and pass it in here. The
+        /// stems are sorted + deduped internally so the hash is invariant
+        /// to caller ordering. Mirrors Rust
+        /// <c>OspreyConfig::reconciliation_parameter_hash_for_stems</c>.
+        /// </summary>
+        public string ReconciliationParameterHashForStems(IReadOnlyList<string> fileStems)
         {
             using (var sha256 = SHA256.Create())
             {
@@ -401,17 +428,31 @@ public string ReconciliationParameterHash()
                 // Mirror Rust's `format!("file_stems:{:?}\n", stems)` output
                 // exactly. {:?} on Vec<String> yields ["a", "b"] with the
                 // brackets and double-quoted, comma-space-separated values.
-                var stems = new List<string>(InputFiles?.Count ?? 0);
-                if (InputFiles != null)
+                // Stems are sorted + deduped here so the hash matches the
+                // Rust side, which also sorts + dedups before hashing.
+                var stems = new List<string>(fileStems?.Count ?? 0);
+                if (fileStems != null)
                 {
-                    foreach (var path in InputFiles)
+                    foreach (var stem in fileStems)
                     {
-                        string stem = Path.GetFileNameWithoutExtension(path);
                         if (!string.IsNullOrEmpty(stem))
                             stems.Add(stem);
                     }
                 }
                 stems.Sort(StringComparer.Ordinal);
+                // Dedup in place (stems is sorted, so duplicates are
+                // adjacent). Rust does `dedup()` on a sorted Vec; same here.
+                int write = 0;
+                for (int read = 0; read < stems.Count; read++)
+                {
+                    if (read == 0 || !string.Equals(stems[read], stems[read - 1], StringComparison.Ordinal))
+                    {
+                        stems[write++] = stems[read];
+                    }
+                }
+                if (write < stems.Count)
+                    stems.RemoveRange(write, stems.Count - write);
+
                 var stemsList = new StringBuilder("[");
                 for (int i = 0; i < stems.Count; i++)
                 {

pwiz_tools/OspreySharp/OspreySharp.IO/FileSaver.cs

@@ -61,7 +61,7 @@ public sealed class FileSaver : IDisposable
         /// Resolves <paramref name="fileName"/> against the current
         /// working directory so a bare-filename argument (no directory
         /// component) lands the temp file alongside its destination
-        /// rather than failing inside <see cref="Path.GetDirectoryName(System.ReadOnlySpan{char})"/>
+        /// rather than failing inside <c>Path.GetDirectoryName</c>
         /// downstream. Diverges from the SharedBatch original which
         /// happens to never see relative paths.
         /// </summary>

pwiz_tools/OspreySharp/OspreySharp.IO/ReconciliationFile.cs

@@ -50,28 +50,43 @@ namespace pwiz.OspreySharp.IO
     /// </summary>
     public class ReconciliationFile
     {
-        /// <summary>Current schema version. Bump on incompatible changes.</summary>
-        public const int CurrentFormatVersion = 1;
+        /// <summary>
+        /// Current schema version. Bump on incompatible changes.
+        ///
+        /// v1: initial format.
+        /// v2: added <c>file_stems</c> so per-file Stage 6 rescore workers
+        ///     can compute the reconciliation parameter hash that the
+        ///     downstream <c>--join-at-pass=2</c> merge node expects (the
+        ///     hash is computed over all files in the join, not the
+        ///     worker's single parquet). Old v1 files deserialize with an
+        ///     empty <see cref="FileStems"/> list; the worker falls back
+        ///     to its <c>OspreyConfig.InputFiles</c> stems in that case,
+        ///     preserving v1 behavior.
+        /// </summary>
+        public const int CurrentFormatVersion = 2;
+
+        [JsonProperty("file_stems", Order = 0)]
+        public List<string> FileStems { get; set; }
 
-        [JsonProperty("forced_integration_actions", Order = 0)]
+        [JsonProperty("forced_integration_actions", Order = 1)]
         public List<ForcedIntegrationEntry> ForcedIntegrationActions { get; set; }
 
-        [JsonProperty("format_version", Order = 1)]
+        [JsonProperty("format_version", Order = 2)]
         public int FormatVersion { get; set; }
 
-        [JsonProperty("gap_fill_targets", Order = 2)]
+        [JsonProperty("gap_fill_targets", Order = 3)]
         public List<GapFillEntry> GapFillTargets { get; set; }
 
-        [JsonProperty("library_hash", Order = 3)]
+        [JsonProperty("library_hash", Order = 4)]
         public string LibraryHash { get; set; }
 
-        [JsonProperty("refined_rt_calibration", Order = 4, NullValueHandling = NullValueHandling.Include)]
+        [JsonProperty("refined_rt_calibration", Order = 5, NullValueHandling = NullValueHandling.Include)]
         public RefinedRtCalibrationJson RefinedRtCalibration { get; set; }
 
-        [JsonProperty("search_hash", Order = 5)]
+        [JsonProperty("search_hash", Order = 6)]
         public string SearchHash { get; set; }
 
-        [JsonProperty("use_cwt_peak_actions", Order = 6)]
+        [JsonProperty("use_cwt_peak_actions", Order = 7)]
         public List<UseCwtPeakEntry> UseCwtPeakActions { get; set; }
 
         /// <summary>