anchor.diff:      lists:foreach(fun(P) ->
           contract(Dag, P)
       end, contraction_paths(Dag)),
  +    {reply, ok, State};
  +
  +handle_call({cleave, Vertex}, _From, #state{dag=Dag}=State) ->
  +    cleave_if_contracted(Dag, Vertex),
  +    {reply, ok, State};
  +
  +handle_call(cleave_all, _From, #state{optimized_map=OptMap}=State) ->
  +    lists:foreach(fun(Pid) ->
  +        spawn_link(fun() ->
  +            lasp_process_sup:terminate_child(lasp_process_sup, Pid)
  +        end)
  +    end, dict:fetch_keys(OptMap)),
       {reply, ok, State};
   
   %% @doc Check if linking the given vertices will introduce a cycle in the graph.
  
positive.code:          terminate/2,
           code_change/3]).
  
  %% @todo Remove. Debug only
  -export([contract/0]).
  
  %% Defines how often an optimization pass happens.
  %% A value of 0 means the optimization happens every time.
  -define(CONTRACTION_INTERVAL, 0).
  
negative.code: %% as part of a path contraction.
  %%
  %% Used during the cleaving step.
  %% @todo Optimize
  -type optimized_map() :: dict:dict(pid(),
                                     {contract_path(),
                                      dict:dict(lasp_vertex(),
                                                {lasp_vertex(), #process_metadata{}})}).
  
  -record(state, {dag :: digraph:graph(),
                  process_map :: process_map(),
  