wideConvert lets the serious errors pass through, use it in Execute

tasks/Execute.scala

@@ -3,8 +3,7 @@
  */
 package sbt
 
-// TODO: Incomplete needs to be parameterized with A[_] and have val node
-
+import ErrorHandling.wideConvert
 import Types._
 import Execute._
 
@@ -215,12 +214,10 @@ final class Execute[A[_] <: AnyRef](checkCycles: Boolean)(implicit view: A ~> No
 	* This returns a Completed instance, which contains the post-processing to perform after the result is retrieved from the Strategy.*/
 	def work[T](node: A[T], f: => Either[A[T], T])(implicit strategy: Strategy): Completed =
 	{
-		val result =
-			try { Right(f) }
-			catch {
-				case i: Incomplete => Left(i)
-				case e => Left( Incomplete(Incomplete.Error, directCause = Some(e)) )
-			}
+		val result = wideConvert(f).left.map {
+			case i: Incomplete => i
+			case e => Incomplete(Incomplete.Error, directCause = Some(e))
+		}
 		completed {
 			result match {
 				case Left(i) => retire(node, Inc(i))

util/control/ErrorHandling.scala

@@ -7,10 +7,17 @@ object ErrorHandling
 {
 	def translate[T](msg: => String)(f: => T) =
 		try { f }
-		catch { case e => throw new TranslatedException(msg + e.toString, e) }
+		catch { case e: Exception => throw new TranslatedException(msg + e.toString, e) }
+
 	def wideConvert[T](f: => T): Either[Throwable, T] =
 		try { Right(f) }
-		catch { case e => Left(e) } // TODO: restrict type of e
+		catch
+		{
+			case ex @ (_: Exception | _: StackOverflowError) => Left(ex)
+			case err @ (_: ThreadDeath | _: VirtualMachineError) => throw err
+			case x => Left(x)
+		}
+
 	def convert[T](f: => T): Either[Exception, T] =
 		try { Right(f) }
 		catch { case e: Exception => Left(e) }