anchor.diff:              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
  +            case get(perhaps_reset_loop) of
  +                undefined ->
  +                    put(perhaps_reset_loop, 1);
  +                X when X > 15 ->
  +                    Msg = lists:flatten(
  +                            io_lib:format("~P", [get(react), 300])),
  +                    exit({not_supposed_to_happen, ?MODULE, ?LINE, Msg});
  +                X ->
  +                    put(perhaps_reset_loop, X+1)
               end,
               %% P_latest is not sane.
               %% By process of elimination, P_newprop is best,
  
positive.code:             %% 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
  
negative.code: 
              P_inner2A = inner_projection_or_self(P_current),
              ResetEpoch = P_newprop10#projection_v1.epoch_number,
              ResetAuthor = case P_current#projection_v1.upi of
                                [] ->
                                    %% Drat, fall back to current's author.
                                    P_current#projection_v1.author_server;
                                _ ->
                                    lists:last(P_current#projection_v1.upi)
                            end,
              ClauseInfo2 = [{move_from_inner_to_outer, true},
                             {old_author, P_inner2A#projection_v1.author_server},
                             {reset_author, ResetAuthor},
                             {reset_epoch, ResetEpoch}],
              P_inner2B =
                  machi_projection:update_checksum(
                    P_inner2A#projection_v1{epoch_number=ResetEpoch,
                                            author_server=ResetAuthor,
                                            dbg=ClauseInfo++ClauseInfo2}),
              ReactI = [{inner2b,machi_projection:make_summary(P_inner2B)}],
              ?REACT({a30, ?LINE, ReactI}),
  io:format(user, "HEE30 ~w ~w ~P\n", [S#ch_mgr.name, self(), get(react), 250]), timer:sleep(100),
              react_to_env_C100(P_inner2B, P_latest, S);
         true ->
              ?REACT({a30, ?LINE, []}),
              react_to_env_A40(Retries, P_newprop10, P_latest,
  