diff --git a/.run/projectTree.run.xml b/.run/projectTree.run.xml
new file mode 100644
index 0000000..c407555
--- /dev/null
+++ b/.run/projectTree.run.xml
@@ -0,0 +1,25 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="projectTree" type="GradleRunConfiguration" factoryName="Gradle">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="--rerun-tasks" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="projectTree" />
+          <option value="--verifyDepth=3" />
+        </list>
+      </option>
+      <option name="vmOptions" />
+    </ExternalSystemSettings>
+    <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
+    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
+    <DebugAllEnabled>false</DebugAllEnabled>
+    <RunAsTest>false</RunAsTest>
+    <method v="2" />
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.run/diagonDAG.run.xml b/.run/taskGraph.run.xml
similarity index 89%
rename from .run/diagonDAG.run.xml
rename to .run/taskGraph.run.xml
index 7bd48b5..25beb3e 100644
--- a/.run/diagonDAG.run.xml
+++ b/.run/taskGraph.run.xml
@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="diagonDAG" type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="taskGraph" type="GradleRunConfiguration" factoryName="Gradle">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
@@ -11,7 +11,7 @@
       <option name="taskNames">
         <list>
           <option value="assemble" />
-          <option value="diagonDAG" />
+          <option value="taskGraph" />
         </list>
       </option>
       <option name="vmOptions" />
diff --git a/.run/tasktree.run.xml b/.run/taskTree.run.xml
similarity index 86%
rename from .run/tasktree.run.xml
rename to .run/taskTree.run.xml
index 28235a3..6b951ab 100644
--- a/.run/tasktree.run.xml
+++ b/.run/taskTree.run.xml
@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="tasktree" type="GradleRunConfiguration" factoryName="Gradle">
+  <configuration default="false" name="taskTree" type="GradleRunConfiguration" factoryName="Gradle">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$" />
@@ -10,8 +10,7 @@
       </option>
       <option name="taskNames">
         <list>
-          <option value="assemble" />
-          <option value="tasktree" />
+          <option value="taskTree" />
         </list>
       </option>
       <option name="vmOptions" />
diff --git a/build.gradle.kts b/build.gradle.kts
index 6862a84..e69de29 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,12 +0,0 @@
-buildscript {
-    repositories {
-        gradlePluginPortal()
-        mavenCentral()
-        google()
-        mavenCentral()
-    }
-    dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.7.21")
-        classpath("org.jetbrains.kotlin:kotlin-serialization:1.7.21")
-    }
-}
\ No newline at end of file
diff --git a/example/build.gradle.kts b/example/build.gradle.kts
index 37d7529..a7df01d 100644
--- a/example/build.gradle.kts
+++ b/example/build.gradle.kts
@@ -1,6 +1,6 @@
 plugins {
-    id("java")
-    id("tasktree")
+    `kotlin-dsl`
+    alias(libs.plugins.tasktree)
 }
 
 val firstTask = tasks.create("simple_first_task") {
@@ -31,17 +31,15 @@ tasks.create("sub_second_task") {
 }
 
 tasktree {
-
-    inputs = false
-    outputs = false
-    printClassName = false
+    printDetails = false
     printPrice = true
     printImportance = true
-    printComplexPrice = true
-    printDoubles = true
-    printImportanceOutSide = true
-
-
+    printRelativePrice = true
+    printDoubles = false
+    printMostExpensive = true
 }
 
+dependencies {
+    implementation(project(":example_core"))
+}
 
diff --git a/example_core/build.gradle.kts b/example_core/build.gradle.kts
new file mode 100644
index 0000000..73f7fb4
--- /dev/null
+++ b/example_core/build.gradle.kts
@@ -0,0 +1,4 @@
+plugins {
+    `kotlin-dsl`
+}
+
diff --git a/gradle.properties b/gradle.properties
index 0dee8cb..bf80f8e 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,4 +1,6 @@
 org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
-android.useAndroidX=true
 kotlin.code.style=official
-android.nonTransitiveRClass=true
\ No newline at end of file
+org.gradle.parallel=true
+org.gradle.caching=true
+org.gradle.configureondemand=true
+org.gradle.configuration-cache=true
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 60c76b3..3bcda61 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12.1-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
\ No newline at end of file
diff --git a/libs.versions.toml b/libs.versions.toml
new file mode 100644
index 0000000..57f0183
--- /dev/null
+++ b/libs.versions.toml
@@ -0,0 +1,14 @@
+[versions]
+
+tasktree = "0.0.9"
+
+[libraries]
+
+[bundles]
+
+
+[plugins]
+
+publish-plugin = { id = "com.gradle.plugin-publish", version = "1.1.0" }
+tasktree = { id = "com.github.klee0kai.tasktree", version.ref = "tasktree" }
+
diff --git a/readme.md b/readme.md
index 92d3fa2..508e105 100644
--- a/readme.md
+++ b/readme.md
@@ -7,29 +7,14 @@ Print gradle task dependencies graph
 
 ## Usage
 
-Configure classpath in project's `build.gradle`:
-
-```kotlin
-buildscript {
-    repositories {
-        maven(url = "https://jitpack.io")
-    }
-    dependencies {
-        classpath("com.github.klee0kai:tasktree:0.0.9")
-    }
-}
-```
-
 Apply plugin in your module's `build.gradle`:
 
 ```kotlin
 plugins {
-    id("tasktree")
+    id("com.github.klee0kai.tasktree") version "0.0.9"
 }
 
 tasktree {
-    inputs = false
-    outputs = false
     printClassName = true
     maxDepth = 1
 }
@@ -38,7 +23,35 @@ tasktree {
 Report your build graph
 
 ```bash
-./gradlew tasktree assemble
+./gradlew taskTree assemble
+
+>>
+:example:assemble price: 12; depth: 6; importance: 3; relativePrice: 0,55; relativeDepth: 0,67;
++--- :example:simple_first_task price: 2; depth: 2; importance: 4; relativePrice: 0,09; relativeDepth: 0,22;
+|    \--- :example:sub_first_task price: 1; depth: 1; importance: 5; relativePrice: 0,05; relativeDepth: 0,11;
+
+```
+
+Verify project's module dependency depth
+
+```bash 
+./gradlew projectTree  --verifyDepth=1
+
+>> Heavy projects: ':example' depth: 2
+```
+
+Build graphs
+
+```bash 
+./gradlew projectGraph
+
+>>
+┌─────────────┐
+│:example_core│
+└┬────────────┘
+┌▽───────┐     
+│:example│     
+└────────┘     
 ```
 
 ## Configure Init Script
@@ -52,7 +65,7 @@ initscript {
         maven(url = "https://jitpack.io")
     }
     dependencies {
-        classpath("com.github.klee0kai:tasktree:0.0.9")
+        classpath("com.github.klee0kai.tasktree:com.github.klee0kai.tasktree.gradle.plugin:0.0.9")
     }
 }
 
@@ -61,7 +74,9 @@ rootProject{
 
     extensions.findByType(com.github.klee0kai.tasktree.TaskTreeExtension::class.java)
         ?.apply {
-            printComplexPrice = true
+            maxDepth = 1
+            printDetails = true
+            printRelativePrice = true
         }
 }
 ```
diff --git a/settings.gradle.kts b/settings.gradle.kts
index c56f4ad..bbdd3a0 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -13,8 +13,14 @@ dependencyResolutionManagement {
         google()
         mavenCentral()
     }
+    versionCatalogs {
+        create("libs") {
+            from(files("libs.versions.toml"))
+        }
+    }
 }
 
 rootProject.name = "taskTree"
 includeBuild("tasktree")
 include("example")
+include("example_core")
diff --git a/tasktree/build.gradle.kts b/tasktree/build.gradle.kts
index ad7aa2e..be83815 100644
--- a/tasktree/build.gradle.kts
+++ b/tasktree/build.gradle.kts
@@ -1,27 +1,16 @@
-buildscript {
-    dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.7.21")
-        classpath("org.jetbrains.kotlin:kotlin-serialization:1.7.21")
-    }
-}
-
 plugins {
     `kotlin-dsl`
     `java-gradle-plugin`
-    id("com.gradle.plugin-publish") version "1.1.0"
-}
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_11
-    targetCompatibility = JavaVersion.VERSION_11
+    alias(libs.plugins.publish.plugin)
 }
 
+group = libs.plugins.tasktree.get().pluginId
 
 gradlePlugin {
     plugins.register("tasktree") {
-        id = "tasktree"
-        group = "com.github.klee0kai"
-        version = "0.0.9"
+        id = libs.plugins.tasktree.get().pluginId
+        group = libs.plugins.tasktree.get().pluginId
+        version = libs.versions.tasktree.get()
         implementationClass = "com.github.klee0kai.tasktree.TaskTreePlugin"
         displayName = "Task Tree"
         description = "Print gradle build dependencies graph"
diff --git a/tasktree/settings.gradle.kts b/tasktree/settings.gradle.kts
index fcfaecd..677f251 100644
--- a/tasktree/settings.gradle.kts
+++ b/tasktree/settings.gradle.kts
@@ -14,6 +14,11 @@ dependencyResolutionManagement {
         mavenCentral()
         maven(url = "https://jitpack.io")
     }
+    versionCatalogs {
+        create("libs") {
+            from(files("../libs.versions.toml"))
+        }
+    }
 }
 
 rootProject.name = "tasktree"
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/TaskStat.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/TaskStat.kt
deleted file mode 100644
index e61ab25..0000000
--- a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/TaskStat.kt
+++ /dev/null
@@ -1,27 +0,0 @@
-package com.github.klee0kai.tasktree
-
-import org.gradle.api.Project
-import org.gradle.api.Task
-
-class TaskStat(
-    val task: Task,
-    val allTasks: Set<Task>,
-    val rootProject: Project,
-) {
-
-    var allDepsCount: Long = 0
-    var allDependedOnCount: Long = 0
-    var allDependedOnOutsideProjectCount: Long = 0
-
-
-    val price get() = allDepsCount
-    val importance get() = allDependedOnCount
-
-    val complexPrice get() = (price * importance).toFloat() / allTasks.size
-
-
-    // ---- outside of project ------
-    val importanceOutsideProject get() = allDependedOnOutsideProjectCount
-    val complexPriceOutsideProject get() = (price * importanceOutsideProject).toFloat() / allTasks.size
-
-}
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/TaskTreeExtension.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/TaskTreeExtension.kt
index 25b2e81..d6bafb0 100644
--- a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/TaskTreeExtension.kt
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/TaskTreeExtension.kt
@@ -2,25 +2,15 @@ package com.github.klee0kai.tasktree
 
 open class TaskTreeExtension {
 
-    /**
-     * Print task inputs
-     */
-    var inputs: Boolean = false
-
-    /**
-     * Print task outputs
-     */
-    var outputs: Boolean = false
-
     /**
      * Graph max depth
      */
     var maxDepth: Int = -1
 
     /**
-     * print task's class type
+     * print task's/project additional details
      */
-    var printClassName: Boolean = false
+    var printDetails: Boolean = false
 
     /**
      * Don't show doubles in graph
@@ -38,29 +28,15 @@ open class TaskTreeExtension {
     var printImportance: Boolean = false
 
     /**
-     * Print the number of dependent tasks from another project
+     * show the relative price from the maximum
      */
-    var printImportanceOutSide: Boolean = false
+    var printRelativePrice: Boolean = false
 
-    /**
-     * Complex price
-     * ```
-     * ( price ) * ( importance )
-     * ```
-     * Show that task expensive to run and necessary for many others
-     */
-    var printComplexPrice: Boolean = false
-
-
-    /**
-     * List sorted list of most expensive tasks
-     */
-    var printMostExpensiveTasks: Boolean = false
 
     /**
-     * List sorted list of most expensive modules
+     * List sorted list of most expensive tasks or projects
      */
-    var printMostExpensiveModules: Boolean = false
+    var printMostExpensive: Boolean = false
 
 }
 
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/TaskTreePlugin.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/TaskTreePlugin.kt
index a2b0415..2a3e6ac 100644
--- a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/TaskTreePlugin.kt
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/TaskTreePlugin.kt
@@ -1,8 +1,6 @@
 package com.github.klee0kai.tasktree
 
-import com.github.klee0kai.tasktree.tasks.DiagonDagTask
-import com.github.klee0kai.tasktree.tasks.FlatListTask
-import com.github.klee0kai.tasktree.tasks.TaskTreeTask
+import com.github.klee0kai.tasktree.tasks.*
 import com.github.klee0kai.tasktree.utils.allRequestedTasks
 import com.github.klee0kai.tasktree.utils.taskGraph
 import org.gradle.api.Plugin
@@ -10,22 +8,34 @@ import org.gradle.api.Project
 
 open class TaskTreePlugin : Plugin<Project> {
 
-    override fun apply(project: Project) = project.applyOnProject()
+    override fun apply(project: Project) {
+        val ext = project.extensions.create("tasktree", TaskTreeExtension::class.java)
+        project.rootProject.applyProjectReportOnProject(ext)
+        project.allprojects.forEach { project -> project.applyTaskReportOnProject(ext) }
+    }
+
+    private fun Project.applyProjectReportOnProject(ext: TaskTreeExtension) {
+        tasks.register("projectTree", ProjectTreeTask::class.java, ext)
+        tasks.register("projectGraph", ProjectsGraphTask::class.java)
+    }
 
-    private fun Project.applyOnProject() {
-        val ext = extensions.create("tasktree", TaskTreeExtension::class.java)
-        val taskTree = tasks.register("tasktree", TaskTreeTask::class.java, ext)
-        val taskDag = tasks.register("diagonDAG", DiagonDagTask::class.java)
-        val flatlist = tasks.register("flatlist", FlatListTask::class.java, ext)
 
-        taskGraph.whenReady {
-            val isTaskTreeRequested = hasTask(taskTree.get()) || hasTask(taskDag.get()) || hasTask(flatlist.get())
-            if (isTaskTreeRequested) {
-                allRequestedTasks.forEach {
-                    it.enabled = false
+    private fun Project.applyTaskReportOnProject(ext: TaskTreeExtension) {
+        afterEvaluate {
+            val taskTree = tasks.register("taskTree", TaskTreeTask::class.java, ext)
+            val taskDag = tasks.register("taskGraph", TaskGraphTask::class.java)
+            val flatlist = tasks.register("flatList", FlatListTask::class.java, ext)
+
+            taskGraph.whenReady {
+                val isTaskTreeRequested = hasTask(taskTree.get()) || hasTask(taskDag.get()) || hasTask(flatlist.get())
+                if (isTaskTreeRequested) {
+                    allRequestedTasks.forEach {
+                        it.enabled = false
+                    }
                 }
             }
         }
+
     }
 
 }
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/info/TaskInfo.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/info/TaskInfo.kt
new file mode 100644
index 0000000..d342b9f
--- /dev/null
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/info/TaskInfo.kt
@@ -0,0 +1,15 @@
+package com.github.klee0kai.tasktree.info
+
+import org.gradle.api.tasks.diagnostics.internal.ProjectDetails
+
+class TaskInfo(
+    val id: Int = 0,
+    val taskName: String,
+    val className: Class<*>? = null,
+    val simpleClassName: String? = null,
+    val projectName: String? = null,
+    val projectDetails: ProjectDetails? = null,
+    val rootProjectDetails: ProjectDetails? = null,
+    val dependencies: MutableList<TaskInfo> = mutableListOf()
+)
+
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/info/TaskStat.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/info/TaskStat.kt
new file mode 100644
index 0000000..a210508
--- /dev/null
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/info/TaskStat.kt
@@ -0,0 +1,102 @@
+package com.github.klee0kai.tasktree.info
+
+import org.gradle.api.tasks.diagnostics.internal.ProjectDetails
+import java.util.*
+
+class TaskStat(
+    val id: Int = 0,
+    val taskName: String,
+    val className: Class<*>? = null,
+    val simpleClassName: String? = null,
+    val projectName: String? = null,
+    val projectDetails: ProjectDetails? = null,
+    val rootProjectDetails: ProjectDetails? = null,
+    val dependencies: MutableSet<TaskStat> = mutableSetOf(),
+    val dependedOnTasks: MutableSet<TaskStat> = mutableSetOf(),
+) {
+
+    var allTasksCount: Int = 0
+    var maxPrice: Int = 0
+    var maxDepth: Int = 0
+
+    val fullName: String = "${projectName}:${taskName}"
+
+    var allDepsCount: Int = 0
+        private set
+        get() {
+            if (field != 0) return field
+            field = allDependencies.count()
+            return field
+        }
+
+    var allDependedOnCount: Int = 0
+        private set
+        get() {
+            if (field != 0) return field
+            field = allDependedOnTasks.count()
+            return field
+        }
+
+    var depth: Int = 0
+        private set
+        get() {
+            if (field != 0) return field
+            var maxDepth = 1
+            val checked = mutableSetOf<Int>()
+            val deps = LinkedList(dependencies.map { it to 2 }.toMutableList())
+            while (deps.isNotEmpty()) {
+                val dep = deps.pollFirst()
+                if (checked.contains(dep.first.id)) continue
+                if (dep.second > maxDepth) maxDepth = dep.second
+                checked.add(dep.first.id)
+                deps.addAll(0, dep.first.dependencies.map { it to dep.second + 1 })
+            }
+            field = maxDepth
+            return field
+        }
+
+    val allDependencies = sequence {
+        val sent = mutableSetOf<Int>()
+        val deps = LinkedList(dependencies.toMutableList())
+        while (deps.isNotEmpty()) {
+            val dep = deps.pollFirst()
+            if (sent.contains(dep.id)) continue
+            yield(dep)
+            sent.add(dep.id)
+            deps.addAll(dep.dependencies)
+        }
+    }
+
+    val allDependedOnTasks = sequence {
+        val sent = mutableSetOf<Int>()
+        val deps = LinkedList(dependedOnTasks.toMutableList())
+        while (deps.isNotEmpty()) {
+            val dep = deps.pollFirst()
+            if (sent.contains(dep.id)) continue
+            yield(dep)
+            sent.add(dep.id)
+            deps.addAll(dep.dependedOnTasks)
+        }
+    }
+
+
+    val price get() = allDepsCount + 1
+    val importance get() = allDependedOnCount
+
+    val relativePrice get() = price.toFloat() / maxPrice.toFloat()
+
+    val relativeDepth get() = depth.toFloat() / maxDepth.toFloat()
+
+}
+
+
+fun TaskInfo.toTaskStat(
+) = TaskStat(
+    id,
+    taskName,
+    className,
+    simpleClassName,
+    projectName,
+    projectDetails,
+    rootProjectDetails,
+)
\ No newline at end of file
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/info/TaskStatHelper.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/info/TaskStatHelper.kt
new file mode 100644
index 0000000..ed17cb4
--- /dev/null
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/info/TaskStatHelper.kt
@@ -0,0 +1,75 @@
+package com.github.klee0kai.tasktree.info
+
+import com.github.klee0kai.tasktree.utils.fullName
+import com.github.klee0kai.tasktree.utils.simpleClassName
+import org.gradle.api.Project
+import org.gradle.api.tasks.diagnostics.internal.ProjectDetails
+
+object TaskStatHelper {
+
+    fun collectAllTasksInfo(project: Project): List<TaskInfo> {
+        val tasksInfos = project.tasks.map { task ->
+            TaskInfo(
+                id = System.identityHashCode(task),
+                taskName = task.name,
+                className = task::class.java,
+                simpleClassName = task.simpleClassName,
+                projectName = project.fullName,
+                projectDetails = ProjectDetails.of(project),
+                rootProjectDetails = ProjectDetails.of(project.rootProject),
+            )
+        }.associateBy { task -> task.id }
+
+        project.tasks.forEach { task ->
+            runCatching {
+                task.taskDependencies.getDependencies(task).forEach { dependsOn ->
+                    val taskStat = tasksInfos[System.identityHashCode(dependsOn)] ?: return@forEach
+                    tasksInfos[System.identityHashCode(task)]?.dependencies?.add(taskStat)
+                }
+            }
+        }
+        return tasksInfos.values.toList()
+    }
+
+    fun calcToTaskStats(taskInfos: List<TaskInfo>): List<TaskStat> {
+        val taskStats = taskInfos.map { taskInfo -> taskInfo.toTaskStat() }
+            .associateBy { task -> task.id }
+
+        taskStats.values.forEach { task ->
+            task.allTasksCount = taskInfos.size
+        }
+
+
+        taskInfos.forEach { taskInfo ->
+            taskInfo.dependencies.forEach { dependsOn ->
+                taskStats[taskInfo.id]?.dependencies?.add(taskStats[dependsOn.id] ?: return@forEach)
+            }
+        }
+
+        taskStats.values.forEach { taskStat ->
+            taskStat.dependencies.forEach { dependsOn ->
+                dependsOn.dependedOnTasks.add(taskStat)
+            }
+        }
+
+        val maxPrice = taskStats.values.maxOfOrNull { it.price } ?: 0
+        val maxDepth = taskStats.values.maxOfOrNull { it.depth } ?: 0
+        taskStats.values.forEach { task ->
+            task.maxPrice = maxPrice
+            task.maxDepth = maxDepth
+        }
+
+        return taskStats.values.toList()
+    }
+
+    fun filterByRequestedTasks(
+        tasksStats: List<TaskStat>,
+        allRequestedTasksIds: Set<Int>,
+    ): List<TaskStat> {
+        if (allRequestedTasksIds.isEmpty()) return tasksStats
+        return tasksStats.filter {
+            it.id in allRequestedTasksIds
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/projectInfo/ProjectInfo.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/projectInfo/ProjectInfo.kt
new file mode 100644
index 0000000..5fc9f7f
--- /dev/null
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/projectInfo/ProjectInfo.kt
@@ -0,0 +1,86 @@
+package com.github.klee0kai.tasktree.projectInfo
+
+import org.gradle.api.tasks.diagnostics.internal.ProjectDetails
+import java.util.*
+
+class ProjectInfo(
+    val name: String,
+    val fullName: String,
+    val path: String,
+    val projectDetails: ProjectDetails,
+    val dependencies: MutableSet<ProjectInfo> = mutableSetOf(),
+    val dependedOnProjects: MutableSet<ProjectInfo> = mutableSetOf(),
+) {
+    var allProjectsCount: Int = 0
+    var maxPrice: Int = 0
+    var maxDepth: Int = 0
+
+    var allDepsCount: Int = 0
+        private set
+        get() {
+            if (field != 0) return field
+            field = allDependencies.count()
+            return field
+        }
+
+    var allDependedOnCount: Int = 0
+        private set
+        get() {
+            if (field != 0) return field
+            field = allDependedOnTasks.count()
+            return field
+        }
+
+
+    val allDependencies = sequence {
+        val sent = mutableSetOf<String>()
+        val deps = LinkedList(dependencies.toMutableList())
+        while (deps.isNotEmpty()) {
+            val dep = deps.pollFirst()
+            if (sent.contains(dep.path)) continue
+            yield(dep)
+            sent.add(dep.path)
+            deps.addAll(dep.dependencies)
+        }
+    }
+
+    val allDependedOnTasks = sequence {
+        val sent = mutableSetOf<String>()
+        val deps = LinkedList(dependedOnProjects.toMutableList())
+        while (deps.isNotEmpty()) {
+            val dep = deps.pollFirst()
+            if (sent.contains(dep.path)) continue
+            yield(dep)
+            sent.add(dep.path)
+            deps.addAll(dep.dependedOnProjects)
+        }
+    }
+
+    var depth: Int = 0
+        private set
+        get() {
+            if (field != 0) return field
+            var maxDepth = 1
+            val checked = mutableSetOf<String>()
+            val deps = LinkedList(dependencies.map { it to 2 }.toMutableList())
+            while (deps.isNotEmpty()) {
+                val dep = deps.pollFirst()
+                if (checked.contains(dep.first.path)) continue
+                if (dep.second > maxDepth) maxDepth = dep.second
+                checked.add(dep.first.path)
+                deps.addAll(0, dep.first.dependencies.map { it to dep.second + 1 })
+            }
+            field = maxDepth
+            return field
+        }
+
+
+    val price get() = allDepsCount + 1
+    val importance get() = allDependedOnCount
+
+    val relativePrice get() = price.toFloat() / maxPrice
+
+    val relativeDepth get() = depth.toFloat() / maxDepth
+
+}
+
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/projectInfo/ProjectStatHelper.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/projectInfo/ProjectStatHelper.kt
new file mode 100644
index 0000000..217154c
--- /dev/null
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/projectInfo/ProjectStatHelper.kt
@@ -0,0 +1,57 @@
+package com.github.klee0kai.tasktree.projectInfo
+
+import com.github.klee0kai.tasktree.utils.fullName
+import org.gradle.api.Project
+import org.gradle.api.artifacts.ProjectDependency
+import org.gradle.api.tasks.diagnostics.internal.ProjectDetails
+
+object ProjectStatHelper {
+
+    fun collectProjectDependencies(rootProject: Project): List<ProjectInfo> {
+        val projectInfos = rootProject.allprojects.map {
+            ProjectInfo(
+                name = it.name,
+                fullName = it.fullName,
+                path = it.path,
+                projectDetails = ProjectDetails.of(it),
+            )
+        }.associateBy { it.name }
+
+        rootProject.allprojects.forEach { project ->
+            val projectInfo = projectInfos[project.name] ?: return@forEach
+            project.configurations
+                .firstOrNull { it.name.contains("implementation") }
+                ?.allDependencies
+                ?.filterIsInstance<ProjectDependency>()
+                ?.forEach { dep ->
+                    val depProjectInfo = projectInfos[dep.name] ?: return@forEach
+                    projectInfo.dependencies.add(depProjectInfo)
+                }
+        }
+
+        return projectInfos.values.toList()
+    }
+
+    fun calcToProjectStats(projectInfos: List<ProjectInfo>): List<ProjectInfo> {
+        val projectInfos = projectInfos.toMutableList()
+
+        projectInfos.forEach { it.allProjectsCount = projectInfos.size }
+
+        projectInfos.forEach { taskStat ->
+            taskStat.dependencies.forEach { dependsOn ->
+                dependsOn.dependedOnProjects.add(taskStat)
+            }
+        }
+
+        val maxPrice = projectInfos.maxOfOrNull { it.price } ?: 0
+        val maxDepth = projectInfos.maxOfOrNull { it.depth } ?: 0
+        projectInfos.forEach { project ->
+            project.maxPrice = maxPrice
+            project.maxDepth = maxDepth
+        }
+
+        return projectInfos
+    }
+
+
+}
\ No newline at end of file
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/BaseReportTask.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/BaseReportTask.kt
index 8ebc16d..6ed5678 100644
--- a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/BaseReportTask.kt
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/BaseReportTask.kt
@@ -1,34 +1,31 @@
 package com.github.klee0kai.tasktree.tasks
 
-import org.gradle.api.Project
+import com.github.klee0kai.tasktree.utils.allRequestedTasks
 import org.gradle.api.tasks.Internal
-import org.gradle.api.tasks.TaskAction
 import org.gradle.api.tasks.diagnostics.ConventionReportTask
+import org.gradle.api.tasks.diagnostics.internal.ProjectDetails
 import org.gradle.api.tasks.diagnostics.internal.ReportGenerator
 import org.gradle.api.tasks.diagnostics.internal.ReportRenderer
 import org.gradle.api.tasks.diagnostics.internal.TextReportRenderer
 import org.gradle.internal.graph.GraphRenderer
+import org.gradle.internal.serialization.Cached
 
 abstract class BaseReportTask : ConventionReportTask() {
 
-    @Internal
-    protected val renderer = TextReportRenderer()
-
     @get:Internal
-    protected val graphRenderer: GraphRenderer? by lazy { GraphRenderer(renderer.textOutput) }
-
-    abstract fun generate(project: Project)
+    protected val projectDetails = Cached.of { ProjectDetails.of(project) }
 
-    @TaskAction
-    fun generate() {
-        reportGenerator().generateReport(projects) {
-            generate(it)
-        }
+    @get:Internal
+    protected val allRequestedTasksIds = Cached.of {
+        project.allRequestedTasks.map { System.identityHashCode(it) }.toSet()
     }
 
+    @Internal
+    protected val renderer = TextReportRenderer()
+
     override fun getRenderer(): ReportRenderer = renderer
 
-    private fun reportGenerator(): ReportGenerator {
+    protected open fun reportGenerator(): ReportGenerator {
         return ReportGenerator(
             getRenderer(),
             clientMetaData,
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/FlatListTask.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/FlatListTask.kt
index 1d2fe6d..a5c6b68 100644
--- a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/FlatListTask.kt
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/FlatListTask.kt
@@ -1,64 +1,57 @@
 package com.github.klee0kai.tasktree.tasks
 
-import com.github.klee0kai.tasktree.TaskStat
 import com.github.klee0kai.tasktree.TaskTreeExtension
-import com.github.klee0kai.tasktree.utils.allRequestedTasks
+import com.github.klee0kai.tasktree.info.TaskStat
+import com.github.klee0kai.tasktree.info.TaskStatHelper
 import com.github.klee0kai.tasktree.utils.formatString
-import com.github.klee0kai.tasktree.utils.fullName
-import com.github.klee0kai.tasktree.utils.simpleClassName
-import org.gradle.api.Project
-import org.gradle.api.Task
+import org.gradle.api.tasks.TaskAction
+import org.gradle.internal.graph.GraphRenderer
 import org.gradle.internal.logging.text.StyledTextOutput
 import org.gradle.internal.logging.text.StyledTextOutput.Style.Description
 import org.gradle.internal.logging.text.StyledTextOutput.Style.Identifier
+import org.gradle.internal.serialization.Cached
 import javax.inject.Inject
 
 open class FlatListTask @Inject constructor(
     private val ext: TaskTreeExtension,
 ) : BaseReportTask() {
 
-    private val statHelper = TaskStatHelper()
-
-    override fun generate(project: Project) {
-        statHelper.collectFrom(project)
-
-        val allTasksOrdered = project.allRequestedTasks
-        allTasksOrdered.forEach { render(task = it) }
+    private val tasksInfos = Cached.of { TaskStatHelper.collectAllTasksInfo(project) }
 
+    private val tasksStats by lazy {
+        TaskStatHelper.calcToTaskStats(tasksInfos.get())
+            .let { TaskStatHelper.filterByRequestedTasks(it, allRequestedTasksIds.get()) }
     }
 
-    private fun render(task: Task) {
-        graphRenderer?.visit({
-            val taskStat = statHelper.taskStat[task] ?: return@visit
-
-            printTaskShort(taskStat)
+    @TaskAction
+    fun generate() {
+        reportGenerator().generateReport(
+            listOf(projectDetails.get()),
+            { it }
+        ) { projectTasks ->
+            val graphRenderer = GraphRenderer(renderer.textOutput)
 
-            if (ext.printClassName) {
-                withStyle(Description)
-                    .text(" class: ${task.simpleClassName};")
-            }
+            tasksStats
+                .sortedBy { it.allDepsCount }
+                .forEach { taskStat ->
+                    graphRenderer.visit({
+                        printTaskShort(taskStat)
 
-            if (task.isIncludedBuild) {
-                withStyle(Description)
-                    .text(" (included build '${task.project.gradle.rootProject.name}')")
-            }
+                        if (ext.printDetails) {
+                            withStyle(Description)
+                                .text(" class: ${taskStat.simpleClassName};")
+                        }
 
-            val inputs by lazy { task.inputs.files.files }
-            if (ext.inputs && inputs.isNotEmpty())
-                withStyle(Description)
-                    .text(" inputs: [ ${inputs.joinToString { it.path }} ] ")
+                    }, /*last child */ true)
 
-            val outputs by lazy { task.outputs.files.files }
-            if (ext.outputs && outputs.isNotEmpty())
-                withStyle(Description)
-                    .text(" outputs: [ ${outputs.joinToString { it.path }} ] ")
-
-        }, /*last child */ true)
+                }
+        }
     }
 
+
     private fun StyledTextOutput.printTaskShort(taskStat: TaskStat) = apply {
         withStyle(Identifier)
-            .text(taskStat.task.fullName)
+            .text(taskStat.taskName)
 
         if (ext.printPrice) {
             withStyle(Description)
@@ -68,19 +61,12 @@ open class FlatListTask @Inject constructor(
             withStyle(Description)
                 .text(" importance: ${taskStat.importance};")
         }
-        if (ext.printImportanceOutSide) {
-            withStyle(Description)
-                .text(" importance outside: ${taskStat.importanceOutsideProject};")
-        }
-        if (ext.printComplexPrice) {
+        if (ext.printRelativePrice) {
             withStyle(Description)
-                .text(" complexPrice: ${taskStat.complexPrice.formatString()};")
+                .text(" relativePrice: ${taskStat.relativePrice.formatString()};")
         }
     }
 
-    private val Task.isIncludedBuild get() = this@FlatListTask.project.gradle != project.gradle
-
-
 }
 
 
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/ProjectTreeTask.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/ProjectTreeTask.kt
new file mode 100644
index 0000000..c5d870b
--- /dev/null
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/ProjectTreeTask.kt
@@ -0,0 +1,154 @@
+package com.github.klee0kai.tasktree.tasks
+
+import com.github.klee0kai.tasktree.TaskTreeExtension
+import com.github.klee0kai.tasktree.projectInfo.ProjectInfo
+import com.github.klee0kai.tasktree.projectInfo.ProjectStatHelper
+import com.github.klee0kai.tasktree.utils.formatString
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.diagnostics.internal.TextReportRenderer
+import org.gradle.api.tasks.options.Option
+import org.gradle.internal.graph.GraphRenderer
+import org.gradle.internal.logging.text.StyledTextOutput
+import org.gradle.internal.logging.text.StyledTextOutput.Style.*
+import org.gradle.internal.serialization.Cached
+import javax.inject.Inject
+
+open class ProjectTreeTask @Inject constructor(
+    private val ext: TaskTreeExtension,
+) : BaseReportTask() {
+
+    private val renderedProjects = mutableSetOf<ProjectInfo>()
+
+    private val projectsInfos = Cached.of { ProjectStatHelper.collectProjectDependencies(project) }
+
+    private val projectsStats by lazy { ProjectStatHelper.calcToProjectStats(projectsInfos.get()) }
+
+    @Input
+    @Optional
+    @set:Option(option = "verifyDepth", description = "Verify project's module depth")
+    protected var verifyDepth: String? = null
+
+    @Input
+    @Optional
+    @set:Option(option = "verifyPrice", description = "Verify project's module price")
+    protected var verifyPrice: String? = null
+
+    @TaskAction
+    fun generate() {
+        renderedProjects.clear()
+        reportGenerator().generateReport(
+            listOf(projectDetails.get()),
+            { it }
+        ) { projects ->
+            val graphRenderer = GraphRenderer(renderer.textOutput)
+            val topProjects = projectsStats
+                .filter { project -> project.allDependedOnCount <= 0L }
+                .sortedByDescending { it.depth }
+            topProjects.forEach { graphRenderer.render(it) }
+
+            renderer.printMostExpensiveProjectsIfNeed()
+            verifyIfNeed()
+        }
+
+    }
+
+    private fun GraphRenderer.render(
+        projectStat: ProjectInfo,
+        lastChild: Boolean = true,
+        depth: Int = 0,
+    ) {
+        visit({
+            printProjectShort(projectStat)
+
+            if (ext.printDetails) {
+                withStyle(Description)
+                    .text(" class: ${projectStat.path};")
+            }
+
+        }, lastChild)
+
+        if (projectStat.dependencies.isEmpty()) return
+
+        if ((!ext.printDoubles && projectStat in renderedProjects) || ext.maxDepth in 0..depth) {
+            startChildren()
+            visit({
+                withStyle(Normal)
+                    .text("***")
+            }, lastChild)
+            completeChildren()
+            return
+        }
+        renderedProjects.add(projectStat)
+
+        startChildren()
+        val depsSize = projectStat.dependencies.size
+        projectStat.dependencies.forEachIndexed { indx, it ->
+            val lastChild = indx >= depsSize - 1
+            render(it, lastChild = lastChild, depth = depth + 1)
+        }
+        completeChildren()
+    }
+
+    private fun TextReportRenderer.printMostExpensiveProjectsIfNeed() {
+        if (ext.printMostExpensive) {
+            val allStat = projectsStats
+                .filter { it.depth > 0 }
+                .sortedByDescending { it.depth }
+            textOutput
+                .println()
+                .withStyle(Header)
+                .println("Most expensive modules:")
+
+            allStat.forEach {
+                renderer.textOutput
+                    .printProjectShort(it)
+                    .println()
+            }
+            textOutput.println()
+        }
+    }
+
+    private fun StyledTextOutput.printProjectShort(projectInfo: ProjectInfo) = apply {
+        withStyle(Identifier)
+            .text(projectInfo.fullName)
+
+        if (ext.printPrice) {
+            withStyle(Description)
+                .text(" price: ${projectInfo.price};")
+
+            withStyle(Description)
+                .text(" depth: ${projectInfo.depth};")
+        }
+        if (ext.printImportance) {
+            withStyle(Description)
+                .text(" importance: ${projectInfo.importance};")
+        }
+        if (ext.printRelativePrice) {
+            withStyle(Description)
+                .text(" relativePrice: ${projectInfo.relativePrice.formatString()};")
+
+            withStyle(Description)
+                .text(" relativeDepth: ${projectInfo.relativeDepth.formatString()};")
+        }
+    }
+
+
+    private fun verifyIfNeed() {
+        val verifyDepth = verifyDepth?.toInt() ?: return
+        var heavyProjects = projectsStats.filter { it.depth > verifyDepth }
+        if (heavyProjects.isNotEmpty()) {
+            throw IllegalStateException("Heavy projects: ${heavyProjects.joinToString("\n") { "'${it.fullName}' depth: ${it.depth}" }}")
+        }
+
+        val verifyPrice = verifyPrice?.toInt() ?: return
+        heavyProjects = projectsStats.filter { it.price > verifyPrice }
+        if (heavyProjects.isNotEmpty()) {
+            throw IllegalStateException("Heavy projects: ${heavyProjects.joinToString("\n") { "'${it.fullName}' price : ${it.price}" }}")
+        }
+    }
+
+}
+
+
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/DiagonDagTask.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/ProjectsGraphTask.kt
similarity index 75%
rename from tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/DiagonDagTask.kt
rename to tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/ProjectsGraphTask.kt
index 52c8730..8f2dbcf 100644
--- a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/DiagonDagTask.kt
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/ProjectsGraphTask.kt
@@ -1,39 +1,39 @@
 package com.github.klee0kai.tasktree.tasks
 
-import com.github.klee0kai.tasktree.utils.allRequestedTasks
-import com.github.klee0kai.tasktree.utils.fullName
-import com.github.klee0kai.tasktree.utils.getDeps
-import com.github.klee0kai.tasktree.utils.taskGraph
+import com.github.klee0kai.tasktree.projectInfo.ProjectStatHelper
 import org.apache.tools.ant.util.TeeOutputStream
-import org.gradle.api.Project
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.TaskAction
+import org.gradle.internal.serialization.Cached
 import org.gradle.process.internal.ExecActionFactory
 import org.gradle.process.internal.ExecException
 import java.io.ByteArrayOutputStream
 import java.io.IOException
 import javax.inject.Inject
 
-open class DiagonDagTask @Inject constructor(
+open class ProjectsGraphTask @Inject constructor(
     @Input
     val objectFactory: ObjectFactory,
     @Input
     val execAction: ExecActionFactory,
 ) : BaseReportTask() {
 
+    private val projectsInfos = Cached.of { ProjectStatHelper.collectProjectDependencies(project) }
+
+    private val projectsStats by lazy { ProjectStatHelper.calcToProjectStats(projectsInfos.get()) }
 
     @Internal
     override fun getDescription(): String =
         "Draw tasktree graph use Diagon. More: https://github.com/ArthurSonzogni/Diagon"
 
 
-    override fun generate(project: Project) {
-        val allTasks = project.allRequestedTasks.toSet()
-
-        val depsCode = allTasks.joinToString("\n") { task ->
-            project.taskGraph.getDeps(task).joinToString("\n") { dep ->
-                "${dep.fullName} ->  ${task.fullName}"
+    @TaskAction
+    fun generate() {
+        val depsCode = projectsStats.joinToString("\n") { project ->
+            project.dependencies.joinToString("\n") { dep ->
+                "${dep.fullName} -> ${project.fullName}"
             }
         }
 
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/TaskGraphTask.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/TaskGraphTask.kt
new file mode 100644
index 0000000..490f752
--- /dev/null
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/TaskGraphTask.kt
@@ -0,0 +1,75 @@
+package com.github.klee0kai.tasktree.tasks
+
+import com.github.klee0kai.tasktree.info.TaskStatHelper
+import org.apache.tools.ant.util.TeeOutputStream
+import org.gradle.api.model.ObjectFactory
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.TaskAction
+import org.gradle.internal.serialization.Cached
+import org.gradle.process.internal.ExecActionFactory
+import org.gradle.process.internal.ExecException
+import java.io.ByteArrayOutputStream
+import java.io.IOException
+import javax.inject.Inject
+
+open class TaskGraphTask @Inject constructor(
+    @Input
+    val objectFactory: ObjectFactory,
+    @Input
+    val execAction: ExecActionFactory,
+) : BaseReportTask() {
+
+    private val tasksInfos = Cached.of { TaskStatHelper.collectAllTasksInfo(project) }
+
+    private val tasksStats by lazy {
+        TaskStatHelper.calcToTaskStats(tasksInfos.get())
+            .let { TaskStatHelper.filterByRequestedTasks(it, allRequestedTasksIds.get()) }
+    }
+
+
+    @Internal
+    override fun getDescription(): String =
+        "Draw tasktree graph use Diagon. More: https://github.com/ArthurSonzogni/Diagon"
+
+
+    @TaskAction
+    fun generate() {
+        val depsCode = tasksStats.joinToString("\n") { task ->
+            task.dependencies.joinToString("\n") { dep ->
+                "${dep.fullName} -> ${task.fullName}"
+            }
+        }
+
+        val result = sh(cmd = arrayOf("diagon", "GraphDAG"), input = depsCode)
+
+        println("------------------  Diagon DAG graph ----------- ")
+        println(result)
+        println("------------------  ---------------- ----------- ")
+    }
+
+
+    private fun sh(cmd: Array<String>, input: String): String {
+        val execAction = execAction.newExecAction()
+
+        val localErrStream = ByteArrayOutputStream()
+        val localOutputStream = ByteArrayOutputStream()
+
+        try {
+            execAction.commandLine(*cmd)
+            execAction.errorOutput = TeeOutputStream(localErrStream, System.err)
+            execAction.standardInput = input.byteInputStream()
+            execAction.standardOutput = localOutputStream
+            val result = execAction.execute()
+
+            if (result.exitValue != 0) {
+                throw ExecException("Cmd ${cmd.joinToString(" ")} finished with exit code ${result.exitValue}")
+            }
+            return String(localOutputStream.toByteArray())
+        } catch (e: Exception) {
+            val errStreamText = String(localErrStream.toByteArray())
+            throw IOException("can't run ${cmd.joinToString(" ")}\n ${e.message} $errStreamText", e)
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/TaskStatHelper.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/TaskStatHelper.kt
deleted file mode 100644
index 6caf860..0000000
--- a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/TaskStatHelper.kt
+++ /dev/null
@@ -1,51 +0,0 @@
-package com.github.klee0kai.tasktree.tasks
-
-import com.github.klee0kai.tasktree.TaskStat
-import com.github.klee0kai.tasktree.utils.allRequestedTasks
-import com.github.klee0kai.tasktree.utils.getDeps
-import com.github.klee0kai.tasktree.utils.taskGraph
-import org.gradle.api.Project
-import org.gradle.api.Task
-
-class TaskStatHelper {
-
-    val taskStat = mutableMapOf<Task, TaskStat>()
-
-    fun collectFrom(project: Project) {
-        taskStat.clear()
-
-        val allTasksSet = project.allRequestedTasks.toSet()
-        allTasksSet.forEach { task ->
-            taskStat.putIfAbsent(
-                task,
-                TaskStat(
-                    task = task,
-                    allTasks = allTasksSet,
-                    rootProject = project
-                )
-            )
-        }
-
-        //https://docs.gradle.org/current/javadoc/org/gradle/api/execution/TaskExecutionGraph.html#getAllTasks--
-        // use sorted list
-        allTasksSet.forEach { task ->
-            val stat = taskStat[task] ?: return@forEach
-            val deps = project.taskGraph.getDeps(task)
-            stat.allDepsCount = deps.count() + deps.sumOf { dep ->
-                taskStat[dep]?.allDepsCount ?: 0
-            }
-        }
-
-        allTasksSet.reversed().forEach { task ->
-            val stat = taskStat[task] ?: return@forEach
-            project.taskGraph.getDeps(task).forEach {
-                val depStat = taskStat[it] ?: return@forEach
-                depStat.allDependedOnCount += 1 + stat.allDependedOnCount
-                if (depStat.task.project != stat.task.project) {
-                    depStat.allDependedOnOutsideProjectCount += 1 + stat.allDependedOnCount
-                }
-            }
-        }
-    }
-
-}
\ No newline at end of file
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/TaskTreeTask.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/TaskTreeTask.kt
index 266360e..9d2d63d 100644
--- a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/TaskTreeTask.kt
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/tasks/TaskTreeTask.kt
@@ -1,93 +1,107 @@
 package com.github.klee0kai.tasktree.tasks
 
-import com.github.klee0kai.tasktree.TaskStat
 import com.github.klee0kai.tasktree.TaskTreeExtension
-import com.github.klee0kai.tasktree.utils.*
-import org.gradle.api.Project
-import org.gradle.api.Task
+import com.github.klee0kai.tasktree.info.TaskStat
+import com.github.klee0kai.tasktree.info.TaskStatHelper
+import com.github.klee0kai.tasktree.utils.formatString
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.diagnostics.internal.TextReportRenderer
+import org.gradle.api.tasks.options.Option
+import org.gradle.internal.graph.GraphRenderer
 import org.gradle.internal.logging.text.StyledTextOutput
 import org.gradle.internal.logging.text.StyledTextOutput.Style.*
+import org.gradle.internal.serialization.Cached
 import javax.inject.Inject
 
 open class TaskTreeTask @Inject constructor(
     private val ext: TaskTreeExtension,
 ) : BaseReportTask() {
 
-    private val renderedTasks = mutableSetOf<Task>()
-    private val statHelper = TaskStatHelper()
+    private val renderedTasks = mutableSetOf<TaskStat>()
 
-    override fun generate(project: Project) {
-        renderedTasks.clear()
-        statHelper.collectFrom(project)
+    private val tasksInfos = Cached.of { TaskStatHelper.collectAllTasksInfo(project) }
 
-        val topTasks = project.allRequestedTasks
-            .filter { task ->
-                val taskStat = statHelper.taskStat[task] ?: return@filter false
-                taskStat.allDependedOnCount <= 0
-            }
-            .reversed()
+    private val tasksStats by lazy {
+        TaskStatHelper.calcToTaskStats(tasksInfos.get())
+            .let { TaskStatHelper.filterByRequestedTasks(it, allRequestedTasksIds.get()) }
+    }
 
-        topTasks.forEach { render(it) }
+    @Input
+    @Optional
+    @set:Option(option = "verifyDepth", description = "Verify tasks depth")
+    protected var verifyDepth: String? = null
 
-        printMostExpensiveTasksIfNeed()
-        printMostExpensiveModulesIfNeed()
+    @Input
+    @Optional
+    @set:Option(option = "verifyPrice", description = "Verify tasks price")
+    protected var verifyPrice: String? = null
+
+    @TaskAction
+    fun generate() {
+        renderedTasks.clear()
+        reportGenerator().generateReport(
+            listOf(projectDetails.get()),
+            { it }
+        ) { projectTasks ->
+            val graphRenderer = GraphRenderer(renderer.textOutput)
+            val topTasks = tasksStats
+                .filter { task ->
+                    if (allRequestedTasksIds.get().isNotEmpty()) {
+                        task.dependedOnTasks.none { allRequestedTasksIds.get().contains(it.id) }
+                    } else {
+                        task.allDependedOnCount <= 0L
+                    }
+                }
+                .sortedByDescending { it.depth }
+            topTasks.forEach { graphRenderer.render(it) }
+
+            renderer.printMostExpensiveTasksIfNeed()
+            verifyIfNeed()
+        }
     }
 
-    private fun render(task: Task, lastChild: Boolean = true, depth: Int = 0) {
-        graphRenderer?.visit({
-            val taskStat = statHelper.taskStat[task] ?: return@visit
+    private fun GraphRenderer.render(taskStat: TaskStat, lastChild: Boolean = true, depth: Int = 0) {
+        visit({
 
             printTaskShort(taskStat)
 
-            if (ext.printClassName) {
+            if (ext.printDetails) {
                 withStyle(Description)
-                    .text(" class: ${task.simpleClassName};")
+                    .text(" class: ${taskStat.className};")
             }
 
-            if (task.isIncludedBuild) {
-                withStyle(Description)
-                    .text(" (included build '${task.project.gradle.rootProject.name}')")
-            }
-
-            val inputs by lazy { task.inputs.files.files }
-            if (ext.inputs && inputs.isNotEmpty())
-                withStyle(Description)
-                    .text(" inputs: [ ${inputs.joinToString { it.path }} ] ")
-
-            val outputs by lazy { task.outputs.files.files }
-            if (ext.outputs && outputs.isNotEmpty())
-                withStyle(Description)
-                    .text(" outputs: [ ${outputs.joinToString { it.path }} ] ")
-
         }, lastChild)
 
-        if ((!ext.printDoubles && task in renderedTasks) || ext.maxDepth in 0..depth) {
-            graphRenderer?.startChildren()
-            graphRenderer?.visit({
+        if (taskStat.dependencies.isEmpty()) return
+
+        if ((!ext.printDoubles && taskStat in renderedTasks) || ext.maxDepth in 0..depth) {
+            startChildren()
+            visit({
                 withStyle(Normal)
                     .text("***")
             }, lastChild)
-            graphRenderer?.completeChildren()
+            completeChildren()
             return
         }
-        renderedTasks.add(task)
+        renderedTasks.add(taskStat)
 
-        graphRenderer?.startChildren()
-        val deps = project.taskGraph.getDeps(task)
-        val depsSize = deps.size
-        deps.forEachIndexed { indx, it ->
+        startChildren()
+        val depsSize = taskStat.dependencies.size
+        taskStat.dependencies.forEachIndexed { indx, it ->
             val lastChild = indx >= depsSize - 1
             render(it, lastChild = lastChild, depth = depth + 1)
         }
-        graphRenderer?.completeChildren()
+        completeChildren()
     }
 
-    private fun printMostExpensiveTasksIfNeed() {
-        if (ext.printMostExpensiveTasks) {
-            val allStat = statHelper.taskStat.values
-                .filter { it.complexPrice > 0 }
-                .sortedByDescending { it.complexPrice }
-            renderer.textOutput
+    private fun TextReportRenderer.printMostExpensiveTasksIfNeed() {
+        if (ext.printMostExpensive) {
+            val allStat = tasksStats
+                .filter { it.depth > 0 }
+                .sortedByDescending { it.depth }
+            textOutput
                 .println()
                 .withStyle(Header)
                 .println("Most expensive tasks:")
@@ -97,60 +111,48 @@ open class TaskTreeTask @Inject constructor(
                     .printTaskShort(it)
                     .println()
             }
-            renderer.textOutput.println()
+            textOutput.println()
         }
     }
 
-    private fun printMostExpensiveModulesIfNeed() {
-        if (ext.printMostExpensiveModules) {
-            val allStat = statHelper.taskStat.values
-                .groupBy { it.task.project }
-                .map { (pr, stat) -> pr to stat.sumOf { it.complexPriceOutsideProject.toDouble() } }
-                .sortedByDescending { (_, price) -> price }
-
-            renderer.textOutput
-                .println()
-                .withStyle(Header)
-                .println("Most expensive modules:")
-
-            allStat.forEach { (proj, price) ->
-                renderer.textOutput.apply {
-                    withStyle(Identifier)
-                        .text(proj.fullName)
-
-                    withStyle(Description)
-                        .text(" complexPrice: ${price.formatString()}")
-
-                    println()
-                }
-            }
-            renderer.textOutput.println()
-        }
-    }
 
     private fun StyledTextOutput.printTaskShort(taskStat: TaskStat) = apply {
         withStyle(Identifier)
-            .text(taskStat.task.fullName)
+            .text(taskStat.fullName)
 
         if (ext.printPrice) {
             withStyle(Description)
                 .text(" price: ${taskStat.price};")
+            withStyle(Description)
+                .text(" depth: ${taskStat.depth};")
         }
         if (ext.printImportance) {
             withStyle(Description)
                 .text(" importance: ${taskStat.importance};")
         }
-        if (ext.printImportanceOutSide) {
+        if (ext.printRelativePrice) {
             withStyle(Description)
-                .text(" importance outside: ${taskStat.importanceOutsideProject};")
-        }
-        if (ext.printComplexPrice) {
+                .text(" relativePrice: ${taskStat.relativePrice.formatString()};")
+
             withStyle(Description)
-                .text(" complexPrice: ${taskStat.complexPrice.formatString()};")
+                .text(" relativeDepth: ${taskStat.relativeDepth.formatString()};")
         }
     }
 
-    private val Task.isIncludedBuild get() = this@TaskTreeTask.project.gradle != project.gradle
+
+    private fun verifyIfNeed() {
+        val verifyDepth = verifyDepth?.toInt() ?: return
+        var heavyTasks = tasksStats.filter { it.depth > verifyDepth }
+        if (heavyTasks.isNotEmpty()) {
+            throw IllegalStateException("Heavy tasks: ${heavyTasks.joinToString("\n") { "'${it.fullName}' depth : ${it.depth}" }}")
+        }
+
+        val verifyPrice = verifyPrice?.toInt() ?: return
+        heavyTasks = tasksStats.filter { it.price > verifyPrice }
+        if (heavyTasks.isNotEmpty()) {
+            throw IllegalStateException("Heavy tasks: ${heavyTasks.joinToString("\n") { "'${it.fullName}' price: ${it.price}" }}")
+        }
+    }
 
 
 }
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/utils/ProjectExt.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/utils/ProjectExt.kt
index 2882054..16175f4 100644
--- a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/utils/ProjectExt.kt
+++ b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/utils/ProjectExt.kt
@@ -1,13 +1,13 @@
 package com.github.klee0kai.tasktree.utils
 
-import com.github.klee0kai.tasktree.tasks.DiagonDagTask
+import com.github.klee0kai.tasktree.tasks.TaskGraphTask
 import com.github.klee0kai.tasktree.tasks.FlatListTask
 import com.github.klee0kai.tasktree.tasks.TaskTreeTask
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.execution.taskgraph.DefaultTaskExecutionGraph
 
-private const val RECURSIVE_DETECT = 10_000
+const val RECURSIVE_DETECT = 100
 
 val Project.fullName
     get() = buildString {
@@ -26,17 +26,35 @@ val Project.taskGraph get() = gradle.taskGraph as DefaultTaskExecutionGraph
 
 val Project.allRequestedTasks
     get() = taskGraph.allTasks
-        .filter { it !is TaskTreeTask && it !is DiagonDagTask && it !is FlatListTask }
+        .filter { it !is TaskTreeTask && it !is TaskGraphTask && it !is FlatListTask }
 
 val Project.parents
     get() = generateSequence(this) {
         runCatching { it.parent }.getOrNull()
     }.take(RECURSIVE_DETECT)
 
-fun DefaultTaskExecutionGraph.getDeps(task: Task): Set<Task> =
-    try {
-        getDependencies(task)
-    } catch (ignore: Exception) {
-        //ignore non available info
-        setOf()
+fun <T> Sequence<T>.recursiveDetect(
+    detectCallback: (List<T>) -> Unit = {},
+): Sequence<T> {
+    val noValue = object {};
+    var ticker = 0
+    var rabbit: Any? = noValue
+    var turtle: Any? = noValue
+    var recursiveDetected = false
+    val recursiveCollection = mutableListOf<T>()
+
+    return onEach {
+        if (recursiveDetected) {
+            recursiveCollection.add(it)
+            if (recursiveCollection.size > 2 && recursiveCollection.first() == recursiveCollection.last()) {
+                detectCallback.invoke(recursiveCollection)
+            }
+        } else {
+            rabbit = it
+            if (turtle == rabbit) recursiveDetected = true
+            ticker = (ticker + 1) % 2
+            if (ticker == 0) turtle = it
+        }
     }
+}
+
diff --git a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/utils/TaskExt.kt b/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/utils/TaskExt.kt
deleted file mode 100644
index 371e9aa..0000000
--- a/tasktree/src/main/kotlin/com/github/klee0kai/tasktree/utils/TaskExt.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-package com.github.klee0kai.tasktree.utils
-
-import org.gradle.api.Task
-
-val Task.fullName get() = "${project.fullName}:${name}"