anchor.diff:                      true ->
                           1
                   end,
  -    {next_state, executing, State#state{lead_partner=Lead, partners=Partners, done_count=DoneCount}, Timeout};
  +    {next_state, executing, State#state{lead_partner=Lead, partners=Partners, done_count=DoneCount}};
   executing({partners, _, _}, State) ->
       {stop, {error, no_convergence}, State};
  -executing({inputs, Input}, #state{mod=PhaseMod, modstate=ModState, timeout=Timeout}=State) ->
  +executing({inputs, Input}, #state{mod=PhaseMod, modstate=ModState, flow_timeout=Timeout}=State) ->
       handle_callback(PhaseMod:handle_input(Input, ModState, Timeout), State);
   executing(inputs_done, #state{mod=PhaseMod, modstate=ModState, done_count=DoneCount0}=State) ->
       case DoneCount0 - 1 of
  
positive.code:             luke_phases:send_inputs_done(Next)
      end,
      {stop, normal, State};
  executing(timeout, #state{cb_timeout=true, mod=Mod, modstate=ModState}=State) ->
      handle_callback(Mod:handle_timeout(ModState), State#state{cb_timeout=false});
  executing(timeout, #state{cb_timeout=false}=State) ->
      {stop, normal, State};
  executing(Event, #state{mod=PhaseMod, modstate=ModState}=State) ->
      handle_callback(PhaseMod:handle_event(Event, ModState), State).
  
  handle_event(_Event, StateName, #state{timeout=Timeout}=State) ->
      {next_state, StateName, State, Timeout}.
  
  handle_sync_event(_Event, _From, StateName, #state{timeout=Timeout}=State) ->
      {reply, ignored, StateName, State, Timeout}.
  handle_info(timeout, executing, #state{cb_timeout=true, mod=Mod, modstate=ModState}=State) ->
      handle_callback(Mod:handle_timeout(ModState), State#state{cb_timeout=false});
  handle_info(timeout, executing, #state{flow=Flow}=State) ->
      luke_phases:send_flow_results(Flow, {error, timeout}),
      luke_phases:send_flow_complete(Flow),
      {stop, normal, State};
  handle_info(Info, _StateName, #state{mod=PhaseMod, modstate=ModState}=State) ->
      handle_callback(PhaseMod:handle_info(Info, ModState), State).
  
  
negative.code:             Accumulate = lists:member(accumulate, Behaviors),
              Converge = lists:member(converge, Behaviors),
              {ok, executing, #state{mod=PhaseMod, modstate=ModState, next_phases=NextPhases,
                                     flow=Flow, accumulate=Accumulate, converge=Converge, flow_timeout=Timeout}};
          {stop, Reason} ->
              {stop, Reason}
      end.
  
  executing({partners, Lead0, Partners0}, #state{converge=true}=State) when is_list(Partners0) ->
      Me = self(),
      Lead = case Lead0 of
                 Me ->
  