anchor.diff:              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) ->
  +executing(timeout, #state{mod=Mod, modstate=ModState}=State) ->
  +    handle_callback(Mod:handle_timeout(ModState), State);
  +executing(timeout, 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_event(_Event, StateName, State) ->
  +    {next_state, StateName, State}.
   
  -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_sync_event(_Event, _From, StateName, State) ->
  +    {reply, ignored, StateName, State}.
  +handle_info(timeout, executing, #state{mod=Mod, modstate=ModState}=State) ->
  +    handle_callback(Mod:handle_timeout(ModState), State);
   handle_info(Info, _StateName, #state{mod=PhaseMod, modstate=ModState}=State) ->
       handle_callback(PhaseMod:handle_info(Info, ModState), State).
   
  
positive.code:                 next_phases,
                  done_count=1,
                  flow,
                  timeout,
                  cb_timeout=false}).
  
  behaviour_info(callbacks) ->
    [{init, 1},
  
negative.code:                     true ->
                          1
                  end,
      {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, 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
  