anchor.diff:                  #projection_v1{epoch_number=Epoch_latest_i,
                                  upi=UPI_latest_i,
                                  repairing=Repairing_latest_i} = P_latest_i,
  +                CurrentRealEpochCheck_p =
  +                    case inner_projection_exists(P_current_real) of
  +                        false ->
  +                            %% We're definitely going to suggest making
  +                            %% outer->inner transition.
  +                            Epoch_latest_i >= P_current_real#projection_v1.epoch_number
  +                            andalso
  +                            Epoch_latest_i >= P_current#projection_v1.epoch_number;
  +                        true ->
  +                            true
  +                    end,
                   ?REACT({a30, ?LINE, [{epoch_latest_i, Epoch_latest_i},
                                        {upi_latest_i, UPI_latest_i},
  +                                     {current_real_epoch_check,
  +                                      CurrentRealEpochCheck_p},
  +                                     {x1,inner_projection_exists(P_current_real)},
  +                                     {x2,Epoch_latest_i},
  +                                     {x3,P_current_real#projection_v1.epoch_number},
  +                                     {x4,P_current#projection_v1.epoch_number},
                                        {repairing_latest_i,Repairing_latest_i}]}),
                   LatestSameEnough_p =
  -                    %% Experiment: With chain length=5, this check is a pain,
  -                    %%             e.g. when make_zerf() verifies last
  -                    %%             history of [c,d,e] *and no inner*, and now
  -                    %%             others have proposed *with an inner* with
  -                    %%             [a/witness,d,e] and bigger epoch.  So, the
  -                    %%             experiment is that if we choose something
  -                    %%             insane here, other steps will figure that
  -                    %%             out and do something safe instead.
  -                    %%
  -                    %% ({UPI_latest_i, Repairing_latest_i} ==
  -                    %%      {UPI_current_x, Repairing_current_x})
  -                    %% andalso
                       UPI_latest_i /= []          % avoid hasty none proj jump
  +                    andalso
  +                    CurrentRealEpochCheck_p
                       andalso
                       Epoch_latest_i >= P_current_ios#projection_v1.epoch_number,
                   CurrentHasInner_and_LatestIsDisjoint_p =
  
positive.code:                   {move_from_inner, MoveFromInnerToNorm_p}],
      ?REACT({a30, ?LINE, ClauseInfo}),
      MoveToNorm_p = MoveFromInnerToNorm_p orelse Kicker_p,
      CurrentHasZerf_p = has_make_zerf_annotation(P_current),
      if MoveToNorm_p,
         P_newprop11#projection_v1.upi == [],
         CMode == cp_mode ->
  
negative.code:                              {zerf_in, machi_projection:make_summary(Zerf)}]}),
                      %% io:format(user, "zerf_in: A29: ~p: ~w\n\t~p\n", [MyName,  machi_projection:make_summary(Zerf), get(yyy_hack)]),
                      #projection_v1{dbg=ZerfDbg} = Zerf,
                      P_current_calc = Zerf#projection_v1{
                                         flap=P_current#projection_v1.flap,
                                         dbg=[{zerf_backstop,true}|ZerfDbg]},
                      react_to_env_A30(Retries, P_latest, LatestUnanimousP,
                                       P_current_calc, S);
                  Zerf ->
                      {{{yo_todo_incomplete_fix_me_cp_mode, line, ?LINE, Zerf}}}
              end;
         true ->
              ?REACT({a29, ?LINE, []}),
              react_to_env_A30(Retries, P_latest, LatestUnanimousP, P_current, S)
      end.
  
  react_to_env_A30(Retries, P_latest, LatestUnanimousP, P_current_calc,
                   #ch_mgr{name=MyName, proj=P_current,
                           consistency_mode=CMode, flap_limit=FlapLimit} = S) ->
      ?REACT(a30),
      %% case length(get(react)) of XX when XX > 500 -> io:format(user, "A30 ~w! ~w: ~P\n", [MyName, XX, get(react), 300]), timer:sleep(500); _ -> ok end,
      AllHosed = [],
      {P_newprop1, S2, Up} = calc_projection(S, MyName, AllHosed, P_current_calc),
      ?REACT({a30, ?LINE, [{current, machi_projection:make_summary(S#ch_mgr.proj)}]}),
      ?REACT({a30, ?LINE, [{calc_current, machi_projection:make_summary(P_current_calc)}]}),
      ?REACT({a30, ?LINE, [{newprop1, machi_projection:make_summary(P_newprop1)}]}),
      ?REACT({a30, ?LINE, [{latest, machi_projection:make_summary(P_latest)}]}),
  
      %% Are we flapping yet?
      {P_newprop2, S3} = calculate_flaps(P_newprop1, P_latest, P_current_calc,
                                         Up, FlapLimit, S2),
  
      %% Move the epoch number up ... originally done in C300.
      #projection_v1{epoch_number=Epoch_newprop2}=P_newprop2,
  