I'm not sure if I'm following you entirely, but if you're saying that the size of the minimal vertex-disjoint path-covering of a DAG is the same as the minimal vertex-disjoint path-covering of its transitive closure, then I'm afraid you're wrong. Consider V = {0, 1, 2, 3, 4} and E = {(0, 2), (1, 2), (2, 3), (2, 4)}. To cover G = (V, E) you need at least three paths, but you can cover its transitive closure with 2 paths.

That said, the general method to solve this problem still works, but you just need to forget about the transitive closure (just do the normal bipartite matching procedure on the graph itself, not its transitive closure).

EDIT: to expand on that for the OP: note that when we cover the DAG with vertex-disjoint paths, each vertex has at most one incoming edge, and at most one outgoing edge. The number of paths is thus equal to the number of vertices with no incoming edges (or equivalently, the number of vertices with no outgoing edges). How can we model this as a bipartite matching problem?

I do have a simple algo put all the vertices in a set A (vertices are ordered by indegree) and do the following until set becomes empty.

const int maxn = 1e5 + 20;
vector<int> graph[maxn];
int indegree[maxn];

int ans = 0;
int solve() {
  set<pair<int,int> > A;
  for(int i=1; i<=V; i++) {
    A.insert({indegree[i], i});
  }
  while(!A.empty()){
     vector<int> B;
     while(!A.empty() && A.begin()->first == 0){
        B.push_back(A.begin()->second);
        A.erase(A.Begin());
     }
     ans = max(ans, B.size());
     for(int I=0; I < B.size(); I++){
       for(int J=0; J < graph[B[I]].size(); J++){
         A.erase({indegree[graph[B[I]][J]],graph[B[I]][J]}) ;
         in degree[graph[B[I]][J]]--;
         A.insert({indegree[graph[B[I]][J]],graph[B[I]][J]});      
       }
     }
 }
 return ans;
}

This is very simple solution i am just checking what is the maximum number of nodes at a given level. and this is the answer.