Right equivalent elements arising in the proof of the Schützenberger Theorem
As suggested by J.-E. Pin in the comments, this claim is wrong in the general case. To prove this statement a counter-example shall be constructed, but this will be done by a Haskell-program (at the bottom of this answer). But first I want to explain what it should do. 
The program looks onto a special kind of maps that map Maybe [-2,-1,0,1,-2] to itself. It suffices to look at maps that only go from [-2,...,2] to Maybe [-2,...,2]. The set of maps that this program looks at is even more limited, because it shall only be those maps, that can be generated by a and b only. The function calculateAll should calculate the all the elements in the monoid generated by these two functions and the identity (this is a rather large monoid with 56 Elements). isAperiodic does what the name suggests, but it does not fail, therefore it is unsafe. Next this program can calculate all the "interesting" candidates, that are those elements of the monoid, whose principal right ideal does not equal the whole monoid and not the principal two-sided ideal. This is done by getCandidates. Then testForOneCandidate generates all the counterexamples for the claim for a fixed element $m$, where only completion with the letter $a$ is considered. This is done as follows:
An element in $m''$, which does not lie in $mM$, but $m''\ast a  \in mM$, is in $M''$. For such an element one only needs to test if $m'' M \neq  mM$. This is what testForOneCandidate does. Retranslating the first result of the call testForOneCandidate (head getCandidates) into potencies of a and b one gets the following in ghci testable counter-example (after loading the code):

*Main&gt; let ba = b `mappend` a
*Main&gt; ba `elem` rightPrincipalIdeal a
False
*Main&gt; let ba2 = ba `mappend` a
*Main&gt; ba2 `elem` rightPrincipalIdeal a
True
*Main&gt; (fromList $ rightPrincipalIdeal ba2) &lt; (fromList
    $ rightPrincipalIdeal a)
True


That is a rather complicated example, but I'm sure that there are simpler ones, it's just the first that I encountered.  

Here is the code:

import Data.List (nub,(\\))
import Data.Set (fromList)

data Element = Element (Int -&gt; Maybe Int)

instance Show Element where
  show (Element f) = show (map f [-2..2])

instance Eq Element where 
  (==) (Element f) (Element g) = (map f [-2..2]) == (map g [-2..2])

instance Ord Element where
  (&lt;=) (Element f) (Element g) = (map f [-2..2]) &lt;= (map g [-2..2])

instance Monoid Element where
  mempty = Element dropOutside
  mappend (Element f) (Element g) = Element $ \i -&gt; ((f i) &gt;&gt;= g)    

-- Helper function
dropOutside :: Int -&gt; Maybe Int
dropOutside i
  | abs (i) &lt;= 2 = Just i
  | otherwise = Nothing

-- First elements that "generate" the monoid
a :: Element
a = Element $ \i -&gt; dropOutside (i+1)

b :: Element
b = Element $ \i -&gt; dropOutside (i-1)

nullElement :: Element
nullElement = Element $ \_ -&gt; Nothing

-- Generates the monoid by the neutral element, a and b.
calculateAll :: [Element]
calculateAll =
  let
      calculateAllRec :: [Element] -&gt; [Element]
      calculateAllRec acc =
          let
              newEs = nub [z| x &lt;- acc, y &lt;- acc,let z = x `mappend` y,z `notElem` acc]
          in case newEs of
               [] -&gt; acc
               _ -&gt; calculateAllRec (acc ++ newEs)
in calculateAllRec [mempty,a,b]

-- Checks whether a given element is aperiodic. (Unsafe)
isAperiodicElement :: Element -&gt; Bool
isAperiodicElement x = isApElRec x x where
  isApElRec x' y'
      | y' == (x' `mappend` y') = True
      | otherwise = isApElRec x' (x' `mappend` y')

-- Checks if the whole monoid is aperiodic. (Unsafe)
isAperiodic :: Bool
isAperiodic = all isAperiodicElement calculateAll

-- Calculates the right ideal generated by a given element.
rightPrincipalIdeal :: Element -&gt; [Element]
rightPrincipalIdeal x = nub [x `mappend` y | y &lt;- calculateAll]

-- Calculates the twosided ideal generated by a given element.
twoSidedPrincipalIdeal :: Element -&gt; [Element]
twoSidedPrincipalIdeal x = nub [z `mappend` x `mappend` y | z &lt;- calculateAll , y &lt;- calculateAll]

-- Calculates all those elements, that generate a right ideal, which is not
-- equal to the whole monoid and the twosided ideal generated by that same element.
-- Results in all elements besides the neutral and the null element.
getCandidates :: [Element]
getCandidates =
  let
      fLcA = fromList calculateAll
  in [x| x &lt;- calculateAll,
         let z = fromList $ rightPrincipalIdeal x,
         z /= fromList (twoSidedPrincipalIdeal x),
         z /= fLcA]     


-- Tests for an element m from getCandidates, if there is an element in M withouth mM
-- that reaches mM by adding an a (which amounts to saying that this element m' is in
-- M''). Therefore m'a is in mM. But also m'aM must not be mM.
testForOneCandidate :: Element -&gt; [Element]
testForOneCandidate m =
  let
     mM = fromList $ rightPrincipalIdeal m
     factorsWithA = [m' | m' &lt;- calculateAll ,
                                m' `notElem` mM,
                                let x = m' `mappend` a,
                                x `elem` mM,
                                fromList (rightPrincipalIdeal x) /= mM ]
  in factorsWithA