Replay a winning fix through a three-way merge when the tree moved

Build 15098930 proved two independent fixes for #27332 on Windows, selected
one, and published neither. Between candidates the panel restores the tree;
by the time the winner was replayed, ItemsViewStyles.xaml no longer matched
its diff at line 82, strict `git apply` refused, and the phase reported "No
fix arms were run" and threw away ninety minutes of validated work.

This was not rare. Across the cached logs, 26 of the 94 runs that produced a
*passing* fix candidate died at exactly this line -- and every run that
failed to apply had a passing candidate to lose. It was the largest single
source of discarded work in the fix phase, and 20 distinct issues are
sitting on a reproduction and a fix that were both proven.

The old comment refused a merge because "guessing at a merge would measure
something else". That is true of fuzzy context matching; it is not true of
--3way, which reconstructs the preimage from the blob ids the diff already
carries and merges against that, and which reports failure instead of
inventing a resolution. The stronger argument is that the result is not
trusted either way: both arms still run, so a merge that landed the wrong
change cannot become a published fix -- it can only fail to reproduce.

Strict apply is still tried first and is still the normal path, so a clean
replay is byte-identical to before. Two consequences of --3way are handled
rather than inherited: a conflicted merge is not all-or-nothing, so the tree
is restored before returning (the reproduction is published from it), and a
successful merge lands staged because --3way implies --index, so the scope
is unstaged back to a plain working-tree edit.

Four mutants, all killed: removing the fallback, removing the restore,
leaving the merge staged, and reaching for the merge when apply succeeded.

Suite by explicit file list: 4037 passed / 35 failed, the same 35
pre-existing failures.

Author: Copilot CI

.github/scripts/Replicate-Issue.Tests.ps1

@@ -10171,6 +10171,12 @@ Describe 'Proving the fix is what turned the reproduction green' {
         $script:appliedPathsBefore = @()
         $script:gitApplied = $false
         $script:gitApplySucceeds = $true
+        # Reality: the three-way fallback is only reached when strict apply
+        # already refused, so it defaults to the outcome that makes the winner
+        # replayable.
+        $script:gitThreeWaySucceeds = $true
+        $script:gitThreeWayAttempted = $false
+        $script:gitResetPaths = @()
 
         function Invoke-LoggedChildProcess {
             param($ScriptPath, $Arguments, $LogPath, $Description, $TimeoutSeconds)
@@ -10210,8 +10216,17 @@ Describe 'Proving the fix is what turned the reproduction green' {
         }
         function git {
             if ($args[0] -eq 'apply') {
-                $script:gitApplied = $script:gitApplySucceeds
-                $global:LASTEXITCODE = if ($script:gitApplySucceeds) { 0 } else { 1 }
+                $threeWay = @($args) -contains '--3way'
+                $succeeded = if ($threeWay) {
+                    $script:gitThreeWayAttempted = $true
+                    $script:gitThreeWaySucceeds
+                } else { $script:gitApplySucceeds }
+                if ($succeeded) { $script:gitApplied = $true }
+                $global:LASTEXITCODE = if ($succeeded) { 0 } else { 1 }
+            }
+            elseif ($args[0] -eq 'reset') {
+                $script:gitResetPaths = @(@($args) | Select-Object -Skip 1)
+                $global:LASTEXITCODE = 0
             }
         }
 
@@ -10264,11 +10279,57 @@ Describe 'Proving the fix is what turned the reproduction green' {
     }
 
     It 'runs nothing when the winning diff no longer applies' {
+        # Both routes have to refuse before the winner is abandoned. Strict
+        # apply alone refusing is routine -- see the three-way test below.
         $script:gitApplySucceeds = $false
+        $script:gitThreeWaySucceeds = $false
         Invoke-ReplicationFixArms @script:armArgs | Should -BeNullOrEmpty
         $script:childRuns | Should -HaveCount 0
     }
 
+    It 'replays a winner whose context moved by falling back to a three-way merge' {
+        # Build 15098930 proved two fixes for #27332 and published neither: the
+        # panel restored ItemsViewStyles.xaml to HEAD between candidates, and
+        # the winner's diff would no longer apply at line 82. Across the cached
+        # logs this destroyed a passing candidate 26 times in 94 fix runs.
+        $script:gitApplySucceeds = $false
+        $script:gitThreeWaySucceeds = $true
+
+        $evidence = Invoke-ReplicationFixArms @script:armArgs
+
+        $script:gitThreeWayAttempted | Should -BeTrue
+        $evidence | Should -Not -BeNullOrEmpty
+        $script:childRuns | Should -HaveCount 2
+    }
+
+    It 'does not reach for a three-way merge when the diff applied cleanly' {
+        Invoke-ReplicationFixArms @script:armArgs | Out-Null
+        $script:gitThreeWayAttempted | Should -BeFalse
+    }
+
+    It 'puts the tree back when a three-way merge conflicts' {
+        # A conflicted three-way is not all-or-nothing like strict apply: it
+        # leaves markers and unmerged index entries. The reproduction is
+        # published from this tree, so it cannot be left carrying them.
+        $script:gitApplySucceeds = $false
+        $script:gitThreeWaySucceeds = $false
+
+        Invoke-ReplicationFixArms @script:armArgs | Should -BeNullOrEmpty
+
+        $script:restoreCalls | Should -Be 1
+    }
+
+    It 'unstages the scope a three-way merge staged behind it' {
+        # --3way implies --index, so the merge lands staged, which no other
+        # path in the phase produces.
+        $script:gitApplySucceeds = $false
+        $script:gitThreeWaySucceeds = $true
+
+        Invoke-ReplicationFixArms @script:armArgs | Out-Null
+
+        $script:gitResetPaths | Should -Contain 'src/Core/src/Handlers/EntryHandler.cs'
+    }
+
     It 'refuses a diff that turns out to touch a file outside the scope' {
         $script:appliedPaths = @('src/Core/src/Handlers/EntryHandler.cs', 'eng/Versions.props')
         Invoke-ReplicationFixArms @script:armArgs | Should -BeNullOrEmpty

.github/scripts/Replicate-Issue.ps1

@@ -5044,11 +5044,41 @@ function Invoke-ReplicationFixArms {
         Where-Object { $ScopeFiles -cnotcontains $_ })
     & git apply --whitespace=nowarn -- $PatchPath
     if ($LASTEXITCODE -ne 0) {
-        # The panel restores the tree between candidates, so the winner's work
-        # has to be replayed here. If it will not replay there is nothing to
-        # measure, and guessing at a merge would measure something else.
-        Write-Host 'No fix arms were run: the winning diff no longer applies to the tree.'
-        return $null
+        # Strict apply is exact but brittle. The panel restores the tree
+        # between candidates, so by the time the winner is replayed the context
+        # around its change can have moved -- on Windows a restore routinely
+        # rewrites line endings, which is enough on its own. Measured over the
+        # cached logs, 26 of the 94 runs that produced a *passing* fix candidate
+        # died right here, and every run that failed to apply had a passing
+        # candidate to lose. It was the largest single source of discarded work
+        # in the fix phase.
+        #
+        # A three-way merge is not the guess the strict path was guarding
+        # against. It reconstructs the preimage from the blob ids the diff
+        # already carries and merges against that; when it cannot, it says so
+        # instead of inventing a resolution. And whatever it produces is still
+        # put through both arms below, so a merge that landed the wrong change
+        # cannot become a published fix -- it can only fail to reproduce.
+        & git apply --3way --whitespace=nowarn -- $PatchPath
+        if ($LASTEXITCODE -ne 0) {
+            # Unlike strict apply, which is all-or-nothing, a conflicted
+            # three-way leaves markers in the file and unmerged entries in the
+            # index. The reproduction is published from this tree, so it has to
+            # be put back before returning.
+            Restore-ReplicationFixTree `
+                -TrustedScriptRoot $TrustedScriptRoot `
+                -ScopeFiles $ScopeFiles | Out-Null
+            Write-Host 'No fix arms were run: the winning diff no longer applies to the tree.'
+            return $null
+        }
+        # --3way implies --index, so the merge lands staged. Nothing downstream
+        # is fooled by that -- status is porcelain and the winner diff is taken
+        # against HEAD -- but leaving the tree in a shape no other path produces
+        # invites a later reader to assume wrongly, so put it back to a plain
+        # working-tree edit. Best effort: if it fails the change is still there.
+        & git reset --quiet -- @ScopeFiles 2>&1 | Out-Null
+        Write-Host ('The winning diff needed a three-way merge to replay, because the ' +
+            'tree moved under it. Both arms still decide whether the fix is real.')
     }
 
     $applied = @(Get-ReplicationFixCandidateChanges -ExcludePaths ($ReproductionPaths + $inheritedDirt))