anchor.diff:  a30_make_inner_projection(P_current, P_newprop3, P_latest, Up,
                             #ch_mgr{name=MyName, consistency_mode=CMode} = S) ->
       AllHosed = get_all_hosed(P_newprop3),
  -    P_current_inner = inner_projection_or_self(P_current),
  -    {P_i, S_i, _Up} = calc_projection2(P_current_inner,
  -                                       MyName, AllHosed, [], S),
  +    P_current_has_inner_p = inner_projection_exists(P_current),
  +    P_current_ios = inner_projection_or_self(P_current),
  +    NewEpochOuter = erlang:max(P_latest#projection_v1.epoch_number + 1,
  +                               P_newprop3#projection_v1.epoch_number),
  +    {P_i1, S_i, _Up} = calc_projection2(P_current_ios,
  +                                        MyName, AllHosed, [], S),
       ?REACT({a30, ?LINE, [{raw_all_hosed,get_all_hosed(P_newprop3)},
                            {up, Up},
                            {all_hosed, AllHosed},
  -                         {p_c_i, machi_projection:make_summary(P_current_inner)},
  -                         {p_i,machi_projection:make_summary(P_i)}]}),
  +                         {p_c_i, machi_projection:make_summary(P_current_ios)},
  +                         {p_i1, machi_projection:make_summary(P_i1)}]}),
       %% The inner projection will have a fake author, which
       %% everyone will agree is the largest UPI member's
       %% name.
       BiggestUPIMember =
  -        if P_i#projection_v1.upi == [] ->
  +        if P_i1#projection_v1.upi == [] ->
                   %% Oops, ok, fall back to author
  -                P_i#projection_v1.author_server;
  +                P_i1#projection_v1.author_server;
              true ->
  -                lists:last(lists:sort(P_i#projection_v1.upi))
  +                lists:last(lists:sort(P_i1#projection_v1.upi))
           end,
  -    P_i2 = P_i#projection_v1{author_server=BiggestUPIMember},
  -    P_inner = case lists:member(MyName, AllHosed)
  -                   andalso
  -                   CMode == ap_mode
  -              of
  -                  false ->
  -                      P_i2;
  -                  true ->
  -                      P_i2#projection_v1{
  -                        upi=[MyName],
  -                        repairing=[],
  -                        down=P_i2#projection_v1.all_members
  -                        -- [MyName]}
  -              end,
  +    P_i2 = P_i1#projection_v1{author_server=BiggestUPIMember},
  +    P_i3 = case lists:member(MyName, AllHosed)
  +               andalso
  +               CMode == ap_mode
  +           of
  +               false ->
  +                   P_i2;
  +               true ->
  +                   %% Fall back to a safe AP mode chain: just me.
  +                   P_i2#projection_v1{
  +                     upi=[MyName],
  +                     repairing=[],
  +                     down=P_i2#projection_v1.all_members
  +                     -- [MyName]}
  +           end,
       #projection_v1{epoch_number=Epoch_p_inner,
                      upi=UPI_p_inner,
  -                   repairing=Repairing_p_inner} = P_inner,
  -    LatestHasCompatibleInner =
  +                   repairing=Repairing_p_inner} = P_i3,
  +    HasCompatibleInner =
           case inner_projection_exists(P_latest) of
               true ->
                   P_latest_i = inner_projection_or_self(P_latest),
  +                #projection_v1{epoch_number=___Epoch_current_x,
  +                               upi=UPI_current_x,
  +                               repairing=Repairing_current_x} = P_current_ios,
                   #projection_v1{epoch_number=Epoch_latest_i,
                                  upi=UPI_latest_i,
                                  repairing=Repairing_latest_i} = P_latest_i,
                   ?REACT({a30, ?LINE, [{epoch_latest_i, Epoch_latest_i},
                                        {upi_latest_i, UPI_latest_i},
                                        {repairing_latest_i}]}),
  -                                                %io:format(user, "INNER: ~p line ~p ~p\n", [{epoch_latest_i, Epoch_latest_i}, {epoch_final_inner, FinalInnerEpoch}, {upi_latest_i, UPI_latest_i}, {repairing_latest_i}]),
  -                if %% TODO yo delete? Epoch_latest_i > FinalInnerEpoch
  -                    %% TODO yo delete? andalso
  -                    UPI_p_inner == UPI_latest_i
  +                SameEnough_p = 
  +                    UPI_latest_i == P_current_ios#projection_v1.upi
                       andalso
  -                    Repairing_p_inner == Repairing_latest_i ->
  -                        %% Use latest's inner projection instead!
  +                    Repairing_latest_i == P_current_ios#projection_v1.repairing
  +                    andalso
  +                    Epoch_latest_i >= P_current_ios#projection_v1.epoch_number,
  +                CurrentInner_and_Disjoint_p = 
  +                    P_current_has_inner_p
  +                    andalso
  +                    ordsets:is_disjoint(
  +                      ordsets:from_list(UPI_current_x ++ Repairing_current_x),
  +                      ordsets:from_list(UPI_latest_i ++ Repairing_latest_i)),
  +                if SameEnough_p ->
                           ?REACT({a30, ?LINE, []}),
  -                                                %io:format(user, "INNER: ~p line ~p\n", [MyName, ?LINE]),
  -                        machi_projection:update_checksum(
  -                          P_inner#projection_v1{inner=P_latest_i});
  +                        P_latest_i;
  +                   CurrentInner_and_Disjoint_p ->
  +                        ?REACT({a30, ?LINE, []}),
  +                        P_current_ios;
                       true ->
                           ?REACT({a30, ?LINE, []}),
                           false
                   end;
               false ->
  -                ?REACT({a30, ?LINE, []}),
  -                false
  +                #projection_v1{upi=UPI_i3,
  +                               repairing=Repairing_i3} = P_i3,
  +                if P_current_has_inner_p,
  +                   UPI_i3 == P_current_ios#projection_v1.upi,
  +                   Repairing_i3 == P_current_ios#projection_v1.repairing ->
  +                        ?REACT({a30, ?LINE, []}),
  +                        P_current_ios;
  +                    true ->
  +                        ?REACT({a30, ?LINE, []}),
  +                        false
  +                end
           end,
  -    if LatestHasCompatibleInner /= false ->
  -            {LatestHasCompatibleInner, S_i};
  +    if HasCompatibleInner /= false ->
  +            P_newprop4 = machi_projection:update_checksum(
  +                      P_newprop3#projection_v1{inner=HasCompatibleInner}),
  +            {P_newprop4, S_i};
          true ->
               FinalInnerEpoch =
                   case inner_projection_exists(P_current) of
  
positive.code:                                     {flap_limit, FlapLimit}]}),
                  {P_newprop3, S3}
          end,
  
      %% Here's a more common reason for moving from inner projection to
      %% a normal projection: the old proj has an inner but the newprop
  
negative.code:                         P_latest#projection_v1.author_server /= MyName,
      ?REACT({a40, ?LINE,
              [{latest_author, P_latest#projection_v1.author_server},
               {author_is_down_p, LatestAuthorDownP},
               {latest_flap, P_latest#projection_v1.flap},
               {newprop_flap, P_newprop#projection_v1.flap}]}),
  
      if
          %% Epoch == 0 is reserved for first-time, just booting conditions.
  