anchor.diff:              %% for repairs when the partition is healed: the quickest author
               %% after the healing will make that choice for everyone.
               %%
  +            %% 2015-07-06: Ha! This works, almost all of the time.  But there
  +            %% is a bug.
  +            %%
  +            %% The bug: if a repair has finished near the time that we fall
  +            %% out of flapping mode and back to normal (one of the reasons
  +            %% that we are here), then it's possible to have a situation like
  +            %% this:
  +            %% outer: {epoch,4638},{author,c},{upi,[e,c]},{repair,[d,a,b]}
  +            %% inner: {epoch,4539},{author,e},{upi,[e,c,d]},{repair,[]}
  +            %%
  +            %% Code prior to today would simply use the inner projection and
  +            %% only keep the outer's epoch number.  However, if we do that,
  +            %% then C100 will fail a sanity check: author e cannot add d to
  +            %% the end of the UPI, only C is allowed to do that.
  +            %%
  +            %% After checking all 5 participants, they all agree with the
  +            %% outer and inner shown above.  But all 5 fail their C100
  +            %% transition safety check, and so all 5 spin in an infinite loop,
  +            %% cool!
  +            %%
  +            %% Fix for today: Send a signal (through a new func arg) to C100
  +            %% that we're moving from inner to outer.  If the
  +            %% 'expected_author2' error is the only sanity check that fails at
  +            %% C100, then that's OK, because: 1. We've lost track of the
  +            %% author, so we can't satisfy the check 100% of the time.  (We
  +            %% have the option of picking the
  +
  +            %%
               %% TODO: Perhaps that quickest author should consult all of the
               %% other private stores, check their inner, and if there is a
               %% higher rank there, then goto C200 for a wait-and-see cycle?
  
positive.code:             %%       in the down list, quite odd!  Go investigate that.
  
              P_inner2A = inner_projection_or_self(P_current),
              P_inner2B =
                  P_inner2A#projection_v1{epoch_number=
                                          P_newprop10#projection_v1.epoch_number,
                                          dbg=ClauseInfo},
              react_to_env_C100(P_inner2B, P_latest, S);
  
         true ->
              ?REACT({a30, ?LINE, []}),
              react_to_env_A40(Retries, P_newprop10, P_latest,
  
negative.code:         _ when P_current#projection_v1.epoch_number == 0 ->
              %% Epoch == 0 is reserved for first-time, just booting conditions.
              ?REACT({c100, ?LINE, [first_write]}),
              erase(perhaps_reset_loop),
              react_to_env_C110(P_latest, S);
          true ->
              ?REACT({c100, ?LINE, [sane]}),
              erase(perhaps_reset_loop),
              react_to_env_C110(P_latest, S);
          _AnyOtherReturnValue ->
  io:format(user, "RESETLOOP: ~p ~w ~P", [MyName, get(perhaps_reset_loop), get(react), 70]),
              if PerhapsReset == reset_loop_maybe ->
                      case get(perhaps_reset_loop) of
                          undefined ->
                              put(perhaps_reset_loop, 1);
                          X when X > 10 ->
                              Msg = lists:flatten(
                                      io_lib:format("~P", [get(react), 200])),
                              exit({not_supposed_to_happen, ?MODULE, ?LINE, Msg});
                          X ->
                              put(perhaps_reset_loop, X+1)
                      end;
                 PerhapsReset == undefined ->
                      ok
              end,
              %% P_latest is not sane.
              %% By process of elimination, P_newprop is best,
              %% so let's write it.
  