diff --git a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TaskManager.kt b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TaskManager.kt
index ff73818c..76b4cdbc 100644
--- a/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TaskManager.kt
+++ b/modules/kobalt-plugin-api/src/main/kotlin/com/beust/kobalt/internal/TaskManager.kt
@@ -145,47 +145,49 @@ class TaskManager @Inject constructor(val args: Args,
             }
 
             if (ti.matches(projectName)) {
-                val taskName = ti.taskName
-                nodeMap[taskName].forEach { task ->
+                val tiTaskName = ti.taskName
+                nodeMap[tiTaskName].forEach { task ->
                     if (task != null && accept(task)) {
                         val toProcess = arrayListOf(task)
                         val seen = hashSetOf<String>()
                         val newToProcess = arrayListOf<T>()
+
+                        fun maybeAddEdge(task: T, mm: Multimap<String, String>, isDependency: Boolean,
+                                reverseEdges: Boolean = false) {
+                            val taskName = toName(task)
+                            mm[taskName]?.forEach { toName ->
+                                val addEdge = isDependency || (!isDependency && taskNames.contains(toName))
+                                log(3, "   addEdge: $addEdge taskName: $taskName toName: $toName")
+                                if (addEdge) {
+                                    nodeMap[toName].forEach { to ->
+                                        if (reverseEdges) {
+                                            log(3, "     Adding reverse edge $to -> $task it=$toName")
+                                            result.addEdge(to, task)
+                                        } else {
+                                            log(3, "    Adding edge $task -> $to")
+                                            result.addEdge(task, to)
+                                        }
+                                        if (!seen.contains(toName(to))) {
+                                            log(3, "    New node to process: $to")
+                                            newToProcess.add(to)
+                                        } else {
+                                            log(3, "    Already seen: $to")
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
                         while (toProcess.size > 0) {
+                            log(3, "  New batch of nodes to process: $toProcess")
                             toProcess.forEach { current ->
                                 result.addNode(current)
                                 seen.add(toName(current))
 
-                                fun maybeAddEdge(taskName: String, mm: Multimap<String, String>, isDependency: Boolean,
-                                        reverseEdges: Boolean = false) {
-                                    mm[taskName]?.forEach {
-                                        val addEdge = isDependency || (!isDependency && taskNames.contains(it))
-                                        log(3, "    addEdge: $addEdge $taskName")
-                                        if (addEdge) {
-                                            nodeMap[it].filter { it != task }.forEach { to ->
-                                                if (reverseEdges) {
-                                                    log(3, "     Adding reverse edge $to -> $task")
-                                                    result.addEdge(to, task)
-                                                } else {
-                                                    log(3, "    Adding edge $task -> $to")
-                                                    result.addEdge(task, to)
-                                                }
-                                                if (!seen.contains(toName(to))) {
-                                                    log(3, "    New node to process: $to")
-                                                    newToProcess.add(to)
-                                                } else {
-                                                    log(3, "    Already seen: $to")
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                                toName(current).let { currentName ->
-                                    maybeAddEdge(currentName, reverseDependsOn, true, true)
-                                    maybeAddEdge(currentName, dependsOn, true, false)
-                                    maybeAddEdge(currentName, runBefore, false, false)
-                                    maybeAddEdge(currentName, runAfter, false, true)
-                                }
+                                maybeAddEdge(current, reverseDependsOn, true, true)
+                                maybeAddEdge(current, dependsOn, true, false)
+                                maybeAddEdge(current, runBefore, false, false)
+                                maybeAddEdge(current, runAfter, false, true)
                             }
                             toProcess.clear()
                             toProcess.addAll(newToProcess)
diff --git a/src/test/kotlin/com/beust/kobalt/internal/TaskManagerTest.kt b/src/test/kotlin/com/beust/kobalt/internal/TaskManagerTest.kt
index f783f187..b50c58aa 100644
--- a/src/test/kotlin/com/beust/kobalt/internal/TaskManagerTest.kt
+++ b/src/test/kotlin/com/beust/kobalt/internal/TaskManagerTest.kt
@@ -43,9 +43,10 @@ class TaskManagerTest @Inject constructor(val taskManager: TaskManager) {
         return result
     }
 
-    @Test
+    @Test(enabled = true)
     fun graphTest() {
 //        KobaltLogger.LOG_LEVEL = 3
+        val t = runCompileTasks(listOf("compile"))
         Assert.assertEquals(runCompileTasks(listOf("compile")), listOf("compile", "postCompile"))
         Assert.assertEquals(runCompileTasks(listOf("postCompile")), listOf("postCompile"))
         Assert.assertEquals(runCompileTasks(listOf("compile", "postCompile")), listOf("compile", "postCompile"))
@@ -84,6 +85,16 @@ class TaskManagerTest @Inject constructor(val taskManager: TaskManager) {
 
     @Test
     fun exampleInTheDocTest() {
+        Assert.assertEquals(runTasks(listOf("assemble"),
+                dependsOn = TreeMultimap.create<String, String>().apply {
+                    put("assemble", "compile")
+                },
+                reverseDependsOn = TreeMultimap.create<String, String>().apply {
+                    put("compile", "copyVersionForWrapper")
+                    put("copyVersionForWrapper", "assemble")
+                }),
+                listOf("compile", "copyVersionForWrapper", "assemble"))
+
         Assert.assertEquals(runTasks(listOf("compile"),
                 dependsOn = TreeMultimap.create<String, String>().apply {
                     put("compile", "clean")