diff --git a/build.sbt b/build.sbt
index f7745694..04284d05 100644
--- a/build.sbt
+++ b/build.sbt
@@ -12,7 +12,7 @@ import laika.config.LinkValidation
 import org.typelevel.sbt.site.TypelevelSiteSettings
 import sbt.librarymanagement.Configurations.ScalaDocTool
 // https://typelevel.org/sbt-typelevel/faq.html#what-is-a-base-version-anyway
-ThisBuild / tlBaseVersion := "0.10" // your current series x.y
+ThisBuild / tlBaseVersion := "0.11" // your current series x.y
 
 ThisBuild / startYear := Some(2019)
 ThisBuild / licenses  := Seq(License.Apache2)
diff --git a/docs/features/tagging.md b/docs/features/tagging.md
index d12df735..adb1fce1 100644
--- a/docs/features/tagging.md
+++ b/docs/features/tagging.md
@@ -1,7 +1,7 @@
 Tagging
 =======
 
-Weaver provides some constructs to dynamically tag tests as `ignored` or `cancelled` :
+Weaver provides some constructs to dynamically tag tests as `ignored` :
 
 ```scala mdoc
 import weaver._
@@ -18,16 +18,6 @@ object TaggingSuite extends SimpleIOSuite {
       y    <- IO.delay(2)
     } yield expect(x == y)
   }
-
-  test("Another on CI") {
-    for {
-      onCI <- IO(sys.env.get("CI").isDefined)
-      _    <- cancel("not on CI").unlessA(onCI)
-      x    <- IO.delay(1)
-      y    <- IO.delay(2)
-    } yield expect(x == y)
-  }
-
 }
 ```
 
diff --git a/modules/core/jvm/src/main/scala/weaver/junit/WeaverRunner.scala b/modules/core/jvm/src/main/scala/weaver/junit/WeaverRunner.scala
index 358f374b..59110e15 100644
--- a/modules/core/jvm/src/main/scala/weaver/junit/WeaverRunner.scala
+++ b/modules/core/jvm/src/main/scala/weaver/junit/WeaverRunner.scala
@@ -53,8 +53,6 @@ class WeaverRunner(cls: Class[_], @unused dummy: Boolean)
       case weaver.TestStatus.Exception =>
         notifier.fireTestStarted(description)
         notifier.fireTestFailure(failure(outcome))
-      case Cancelled =>
-        notifier.fireTestIgnored(description)
       case Ignored =>
         notifier.fireTestIgnored(description)
     }
diff --git a/modules/core/shared/src/main/scala/weaver/Comparison.scala b/modules/core/shared/src/main/scala/weaver/Comparison.scala
index 16cef6dd..4620dcf4 100644
--- a/modules/core/shared/src/main/scala/weaver/Comparison.scala
+++ b/modules/core/shared/src/main/scala/weaver/Comparison.scala
@@ -9,9 +9,9 @@ import munit.diff.Diffs
  * A type class used to compare two instances of the same type and construct an
  * informative report.
  *
- * If the comparison succeeds with [[Result.Success]] then no report is printed.
- * If the comparison fails with [[Result.Failure]], then the report is printed
- * with the test failure.
+ * If the comparison succeeds with [[Comparison.Result.Success]] then no report
+ * is printed. If the comparison fails with [[Comparison.Result.Failure]], then
+ * the report is printed with the test failure.
  *
  * The report is generally a diff of the `expected` and `found` values. It may
  * use ANSI escape codes to add color.
diff --git a/modules/core/shared/src/main/scala/weaver/Expectations.scala b/modules/core/shared/src/main/scala/weaver/Expectations.scala
index d95e97b9..13c909b1 100644
--- a/modules/core/shared/src/main/scala/weaver/Expectations.scala
+++ b/modules/core/shared/src/main/scala/weaver/Expectations.scala
@@ -6,7 +6,7 @@ import cats.data.{ NonEmptyList, Validated, ValidatedNel }
 import cats.effect.Sync
 import cats.syntax.all._
 
-case class Expectations(run: ValidatedNel[AssertionException, Unit]) {
+case class Expectations(run: ValidatedNel[ExpectationFailed, Unit]) {
   self =>
 
   /**
@@ -108,7 +108,7 @@ case class Expectations(run: ValidatedNel[AssertionException, Unit]) {
    */
   def traced(loc: SourceLocation): Expectations =
     Expectations(run.leftMap(_.map(e =>
-      e.copy(locations = e.locations.append(loc)))))
+      e.withLocation(loc))))
 
 }
 
@@ -147,8 +147,8 @@ object Expectations {
       override def empty: Additive =
         Additive(
           Expectations(
-            Validated.invalidNel(new AssertionException("empty",
-                                                        NonEmptyList.of(loc)))))
+            Validated.invalidNel(new ExpectationFailed("empty",
+                                                       NonEmptyList.of(loc)))))
 
       override def combine(x: Additive, y: Additive): Additive =
         Additive(
@@ -167,7 +167,7 @@ object Expectations {
     val success: Expectations = Monoid[Expectations].empty
 
     def failure(hint: String)(implicit pos: SourceLocation): Expectations =
-      Expectations(Validated.invalidNel(new AssertionException(
+      Expectations(Validated.invalidNel(new ExpectationFailed(
         hint,
         NonEmptyList.of(pos))))
 
@@ -279,6 +279,13 @@ object Expectations {
       case Invalid(_) => success
     }
 
+    /**
+     * Raises an error that leads to the running test being tagged as "ignored"
+     */
+    def ignore[F[_]: Sync](reason: String)(implicit
+        pos: SourceLocation): F[Nothing] =
+      Sync[F].raiseError(new IgnoredException(reason, pos))
+
     implicit class StringOps(str: String) {
       def ignore(implicit loc: SourceLocation): TestName =
         new TestName(str, loc, Set.empty).ignore
diff --git a/modules/core/shared/src/main/scala/weaver/Formatter.scala b/modules/core/shared/src/main/scala/weaver/Formatter.scala
index 1823a04b..51a5af1f 100644
--- a/modules/core/shared/src/main/scala/weaver/Formatter.scala
+++ b/modules/core/shared/src/main/scala/weaver/Formatter.scala
@@ -43,11 +43,11 @@ object Formatter {
     import Result._
 
     result match {
-      case Success                                 => withPrefix(green("+ "))
-      case _: Failure | _: Failures | _: Exception => withPrefix(red("- "))
-      case _: Cancelled =>
-        withPrefix(yellow("- ")) + yellow(" !!! CANCELLED !!!")
-      case _: Ignored => withPrefix(yellow("- ")) + yellow(" !!! IGNORED !!!")
+      case Success => withPrefix(green("+ "))
+      case OnlyTagNotAllowedInCI(_) | Failures(_) | Exception(_) =>
+        withPrefix(red("- "))
+      case Ignored(_, _) =>
+        withPrefix(yellow("- ")) + yellow(" !!! IGNORED !!!")
     }
   }
 
diff --git a/modules/core/shared/src/main/scala/weaver/Result.scala b/modules/core/shared/src/main/scala/weaver/Result.scala
index 8b5c883c..47230660 100644
--- a/modules/core/shared/src/main/scala/weaver/Result.scala
+++ b/modules/core/shared/src/main/scala/weaver/Result.scala
@@ -1,57 +1,59 @@
 package weaver
 
-import scala.util.Try
-
 import cats.data.NonEmptyList
 import cats.data.Validated.{ Invalid, Valid }
 
-sealed trait Result {
+private[weaver] sealed trait Result {
   def formatted: Option[String]
 }
 
-object Result {
+private[weaver] object Result {
   import Formatter._
 
   def fromAssertion(assertion: Expectations): Result = assertion.run match {
     case Valid(_) => Success
     case Invalid(failed) =>
       Failures(failed.map(ex =>
-        Result.Failure(ex.message, Some(ex), ex.locations.toList)))
+        Failures.Failure(ex.message, ex, ex.locations)))
   }
 
   case object Success extends Result {
     def formatted: Option[String] = None
   }
 
-  final case class Ignored(reason: Option[String], location: SourceLocation)
+  final case class Ignored(reason: String, location: SourceLocation)
       extends Result {
 
     def formatted: Option[String] = {
-      reason.map(msg => indent(msg, List(location), Console.YELLOW, TAB2))
+      Some(formatDescription(reason,
+                             List(location),
+                             Console.YELLOW,
+                             TAB2.prefix))
     }
   }
 
-  final case class Cancelled(reason: Option[String], location: SourceLocation)
+  final case class Failures(failures: NonEmptyList[Failures.Failure])
       extends Result {
 
-    def formatted: Option[String] = {
-      reason.map(msg => indent(msg, List(location), Console.YELLOW, TAB2))
-    }
-  }
-
-  final case class Failures(failures: NonEmptyList[Failure]) extends Result {
-
     def formatted: Option[String] =
-      if (failures.size == 1) failures.head.formatted
-      else {
+      if (failures.size == 1) {
+        val failure = failures.head
+        val formattedMessage = formatDescription(
+          failure.msg,
+          failure.locations.toList,
+          Console.RED,
+          TAB2.prefix
+        ) + DOUBLE_EOL
+        Some(formattedMessage)
+      } else {
 
         val descriptions = failures.zipWithIndex.map {
           case (failure, idx) =>
             import failure._
 
             formatDescription(
-              if (msg != null && msg.nonEmpty) msg else "Test failed",
-              location,
+              msg,
+              locations.toList,
               Console.RED,
               s" [$idx] "
             )
@@ -61,20 +63,29 @@ object Result {
       }
   }
 
-  final case class Failure(
-      msg: String,
-      source: Option[Throwable],
-      location: List[SourceLocation])
+  object Failures {
+    final case class Failure(
+        msg: String,
+        source: Throwable,
+        locations: NonEmptyList[SourceLocation])
+  }
+
+  final case class OnlyTagNotAllowedInCI(
+      location: SourceLocation)
       extends Result {
 
-    def formatted: Option[String] =
-      Some(formatError(msg, source, location, Some(0)))
+    def formatted: Option[String] = {
+      val formattedMessage = formatDescription(
+        "'Only' tag is not allowed when `isCI=true`",
+        List(location),
+        Console.RED,
+        TAB2.prefix
+      ) + DOUBLE_EOL
+      Some(formattedMessage)
+    }
   }
 
-  final case class Exception(
-      source: Throwable,
-      location: Option[SourceLocation])
-      extends Result {
+  final case class Exception(source: Throwable) extends Result {
 
     def formatted: Option[String] = {
       val description = {
@@ -85,16 +96,7 @@ object Result {
           .fold(className)(m => s"$className: $m")
       }
 
-      val maxStackFrames = sys.props.get("WEAVER_MAX_STACKFRAMES").flatMap(s =>
-        Try(s.trim.toInt).toOption).getOrElse(50)
-
-      val stackTraceLimit =
-        if (location.isDefined) Some(maxStackFrames) else None
-
-      Some(formatError(description,
-                       Some(source),
-                       location.toList,
-                       stackTraceLimit))
+      Some(formatError(description, source))
     }
   }
 
@@ -102,27 +104,22 @@ object Result {
 
   def from(error: Throwable): Result = {
     error match {
-      case ex: AssertionException =>
-        Result.Failure(ex.message, Some(ex), ex.locations.toList)
+      case ex: ExpectationFailed =>
+        Failures(NonEmptyList.of(Failures.Failure(
+          ex.message,
+          ex,
+          ex.locations)))
       case ex: IgnoredException =>
-        Result.Ignored(ex.reason, ex.location)
-      case ex: CanceledException =>
-        Result.Cancelled(ex.reason, ex.location)
-      case ex: WeaverException =>
-        Result.Exception(ex, Some(ex.getLocation))
+        Ignored(ex.reason, ex.location)
       case other =>
-        Result.Exception(other, None)
+        Exception(other)
     }
   }
 
-  private def formatError(
-      msg: String,
-      source: Option[Throwable],
-      location: List[SourceLocation],
-      traceLimit: Option[Int]): String = {
+  private def formatError(msg: String, source: Throwable): String = {
 
-    val stackTrace = source.fold("") { ex =>
-      val stackTraceLines = TestErrorFormatter.formatStackTrace(ex, traceLimit)
+    val stackTrace = {
+      val stackTraceLines = TestErrorFormatter.formatStackTrace(source, None)
 
       def traverseCauses(ex: Throwable): Vector[Throwable] = {
         Option(ex.getCause) match {
@@ -131,24 +128,27 @@ object Result {
         }
       }
 
-      val causes = traverseCauses(ex)
+      val causes = traverseCauses(source)
       val causeStackTraceLines = causes.flatMap { cause =>
         Vector(EOL + "Caused by: " + cause.toString + EOL) ++
-          TestErrorFormatter.formatStackTrace(cause, traceLimit)
+          TestErrorFormatter.formatStackTrace(cause, None)
       }
 
       val errorOutputLines = stackTraceLines ++ causeStackTraceLines
 
       if (errorOutputLines.nonEmpty) {
-        indent(errorOutputLines.mkString(EOL), Nil, Console.RED, TAB2)
+        formatDescription(errorOutputLines.mkString(EOL),
+                          Nil,
+                          Console.RED,
+                          TAB2.prefix)
       } else ""
     }
 
-    val formattedMessage = indent(
-      if (msg != null && msg.nonEmpty) msg else "Test failed",
-      location,
+    val formattedMessage = formatDescription(
+      msg,
+      Nil,
       Console.RED,
-      TAB2
+      TAB2.prefix
     )
 
     var res = formattedMessage + DOUBLE_EOL
@@ -164,38 +164,19 @@ object Result {
       color: String,
       prefix: String): String = {
 
-    val footer = locationFooter(location)
-    val lines = (message.split("\\r?\\n") ++ footer).zipWithIndex.map {
-      case (line, index) =>
-        if (index == 0)
-          color + prefix + line +
-            location
-              .map(l => s" (${l.fileRelativePath}:${l.line})")
-              .mkString("\n")
-        else
-          color + prefix + line
-    }
-
-    lines.mkString(EOL) + Console.RESET
-  }
-
-  private def indent(
-      message: String,
-      location: List[SourceLocation],
-      color: String,
-      width: Tabulation): String = {
-
-    val footer = locationFooter(location)
+    val prefixIsWhitespace = prefix.trim.isEmpty
+    val footer             = locationFooter(location)
     val lines = (message.split("\\r?\\n") ++ footer).zipWithIndex.map {
       case (line, index) =>
-        val prefix = if (line.trim == "") "" else width.prefix
+        val linePrefix =
+          if (prefixIsWhitespace && line.trim.isEmpty) "" else prefix
         if (index == 0)
-          color + prefix + line +
+          color + linePrefix + line +
             location
               .map(l => s" (${l.fileRelativePath}:${l.line})")
               .mkString("\n")
         else
-          color + prefix + line
+          color + linePrefix + line
     }
 
     lines.mkString(EOL) + Console.RESET
diff --git a/modules/core/shared/src/main/scala/weaver/Runner.scala b/modules/core/shared/src/main/scala/weaver/Runner.scala
index 18b0e206..db3f7d5d 100644
--- a/modules/core/shared/src/main/scala/weaver/Runner.scala
+++ b/modules/core/shared/src/main/scala/weaver/Runner.scala
@@ -104,30 +104,27 @@ object Runner {
   case class Outcome(
       successes: Int,
       ignored: Int,
-      cancelled: Int,
       failures: Int) { self =>
 
-    def total = successes + ignored + cancelled + failures
+    def total = successes + ignored + failures
 
     def formatted: String =
-      s"Total $total, Failed $failures, Passed $successes, Ignored $ignored, Cancelled $cancelled"
+      s"Total $total, Failed $failures, Passed $successes, Ignored $ignored"
 
   }
 
   object Outcome {
-    val empty = Outcome(0, 0, 0, 0)
+    val empty = Outcome(0, 0, 0)
 
     def fromEvent(event: TestOutcome): Outcome = event.status match {
       case TestStatus.Exception =>
-        Outcome(0, 0, 0, failures = 1)
+        Outcome(0, 0, failures = 1)
       case TestStatus.Failure =>
-        Outcome(0, 0, 0, failures = 1)
+        Outcome(0, 0, failures = 1)
       case TestStatus.Success =>
-        Outcome(successes = 1, 0, 0, 0)
+        Outcome(successes = 1, 0, 0)
       case TestStatus.Ignored =>
-        Outcome(0, ignored = 1, 0, 0)
-      case TestStatus.Cancelled =>
-        Outcome(0, 0, cancelled = 1, 0)
+        Outcome(0, ignored = 1, 0)
     }
 
     implicit val monoid: Monoid[Outcome] = new Monoid[Outcome] {
@@ -136,7 +133,6 @@ object Runner {
       override def combine(left: Outcome, right: Outcome) = Outcome(
         left.successes + right.successes,
         left.ignored + right.ignored,
-        left.cancelled + right.cancelled,
         left.failures + right.failures
       )
     }
diff --git a/modules/core/shared/src/main/scala/weaver/TestOutcome.scala b/modules/core/shared/src/main/scala/weaver/TestOutcome.scala
index 2875dddc..cc9c5609 100644
--- a/modules/core/shared/src/main/scala/weaver/TestOutcome.scala
+++ b/modules/core/shared/src/main/scala/weaver/TestOutcome.scala
@@ -35,21 +35,19 @@ object TestOutcome {
       extends TestOutcome {
 
     def status: TestStatus = result match {
-      case Result.Success                               => TestStatus.Success
-      case Result.Cancelled(_, _)                       => TestStatus.Cancelled
-      case Result.Ignored(_, _)                         => TestStatus.Ignored
-      case Result.Failure(_, _, _) | Result.Failures(_) => TestStatus.Failure
-      case Result.Exception(_, _)                       => TestStatus.Exception
+      case Result.Success       => TestStatus.Success
+      case Result.Ignored(_, _) => TestStatus.Ignored
+      case Result.OnlyTagNotAllowedInCI(_) | Result.Failures(_) =>
+        TestStatus.Failure
+      case Result.Exception(_) => TestStatus.Exception
     }
 
     def cause: Option[Throwable] = result match {
-      case Result.Exception(cause, _)       => Some(cause)
-      case Result.Failure(_, maybeCause, _) => maybeCause
-      case Result.Failures(failures) =>
-        failures.collectFirst {
-          case Result.Failure(_, Some(cause), _) => cause
-        }
-      case _ => None
+      case Result.Exception(cause)   => Some(cause)
+      case Result.Failures(failures) => Some(failures.head.source)
+      case Result.OnlyTagNotAllowedInCI(_) | Result.Ignored(
+            _,
+            _) | Result.Success => None
     }
 
     def formatted(mode: Mode): String =
diff --git a/modules/core/shared/src/main/scala/weaver/TestStatus.scala b/modules/core/shared/src/main/scala/weaver/TestStatus.scala
index 4f664d50..194e84c5 100644
--- a/modules/core/shared/src/main/scala/weaver/TestStatus.scala
+++ b/modules/core/shared/src/main/scala/weaver/TestStatus.scala
@@ -2,13 +2,13 @@ package weaver
 
 sealed abstract class TestStatus(val label: String) {
   def isFailed = this match {
-    case TestStatus.Success | TestStatus.Cancelled | TestStatus.Ignored => false
-    case TestStatus.Failure | TestStatus.Exception                      => true
+    case TestStatus.Success | TestStatus.Ignored   => false
+    case TestStatus.Failure | TestStatus.Exception => true
   }
 }
 object TestStatus {
   val values: List[TestStatus] =
-    List(Success, Cancelled, Ignored, Failure, Exception)
+    List(Success, Ignored, Failure, Exception)
 
   def fromString(s: String): Either[String, TestStatus] =
     values.find(_.label == s) match {
@@ -17,7 +17,6 @@ object TestStatus {
     }
 
   case object Success   extends TestStatus("success")
-  case object Cancelled extends TestStatus("cancelled")
   case object Ignored   extends TestStatus("ignored")
   case object Failure   extends TestStatus("failure")
   case object Exception extends TestStatus("exception")
diff --git a/modules/core/shared/src/main/scala/weaver/exceptions.scala b/modules/core/shared/src/main/scala/weaver/exceptions.scala
index 83c81e9e..8b476153 100644
--- a/modules/core/shared/src/main/scala/weaver/exceptions.scala
+++ b/modules/core/shared/src/main/scala/weaver/exceptions.scala
@@ -1,64 +1,21 @@
 package weaver
 
-import scala.util.control.NonFatal
-
 import cats.data.NonEmptyList
 
-abstract class WeaverException(
-    message: String,
-    cause: Option[Throwable],
-    location: SourceLocation)
-    extends RuntimeException(message, cause.orNull) {
-
-  def getLocation: SourceLocation = location
-
-}
-
-sealed abstract class WeaverTestException(
-    message: String,
-    cause: Option[Throwable],
-    location: SourceLocation)
-    extends WeaverException(message, cause, location)
-
-final case class AssertionException(
-    message: String,
-    locations: NonEmptyList[SourceLocation])
-    extends WeaverTestException(message, None, locations.head)
-
-final class IgnoredException(
-    val reason: Option[String],
-    val location: SourceLocation)
-    extends WeaverTestException(reason.orNull, None, location)
-
-final class CanceledException(
-    val reason: Option[String],
-    val location: SourceLocation)
-    extends WeaverTestException(reason.orNull, None, location)
-
-object OurException {
-
-  /**
-   * Utility for pattern matching.
-   */
-  def unapply(ex: Throwable): Option[WeaverException] = ex match {
-    case ref: WeaverTestException =>
-      Some(ref)
-    case _ =>
-      None
-  }
+private[weaver] sealed abstract class WeaverTestException(
+    message: String
+) extends RuntimeException(message)
+
+final class ExpectationFailed private[weaver] (
+    private[weaver] val message: String,
+    private[weaver] val locations: NonEmptyList[SourceLocation])
+    extends WeaverTestException(message) {
+  private[weaver] def withLocation(
+      location: SourceLocation): ExpectationFailed =
+    new ExpectationFailed(message, locations.append(location))
 }
 
-object NotOurException {
-
-  /**
-   * Utility for pattern matching.
-   */
-  def unapply(ex: Throwable) = ex match {
-    case OurException(_) =>
-      None
-    case NonFatal(_) =>
-      Some(ex)
-    case _ =>
-      None
-  }
-}
+private[weaver] final class IgnoredException(
+    private[weaver] val reason: String,
+    private[weaver] val location: SourceLocation)
+    extends WeaverTestException(reason)
diff --git a/modules/core/shared/src/main/scala/weaver/internals/Clues.scala b/modules/core/shared/src/main/scala/weaver/internals/Clues.scala
index e9c96356..4ed886b6 100644
--- a/modules/core/shared/src/main/scala/weaver/internals/Clues.scala
+++ b/modules/core/shared/src/main/scala/weaver/internals/Clues.scala
@@ -3,7 +3,7 @@ import scala.annotation.implicitNotFound
 import cats.data.{ NonEmptyList, Validated }
 
 import weaver.Expectations
-import weaver.AssertionException
+import weaver.ExpectationFailed
 import weaver.SourceLocation
 import cats.data.Chain
 
@@ -74,7 +74,7 @@ object Clues {
       val fullMessage = header + sourceCodeMessage + "\n\n" + cluesMessage
 
       val exception =
-        new AssertionException(fullMessage, NonEmptyList.of(sourceLoc))
+        new ExpectationFailed(fullMessage, NonEmptyList.of(sourceLoc))
       Expectations(Validated.invalidNel(exception))
     }
   }
diff --git a/modules/core/shared/src/main/scala/weaver/internals/ExpectSame.scala b/modules/core/shared/src/main/scala/weaver/internals/ExpectSame.scala
index 82dccb07..d80f1b97 100644
--- a/modules/core/shared/src/main/scala/weaver/internals/ExpectSame.scala
+++ b/modules/core/shared/src/main/scala/weaver/internals/ExpectSame.scala
@@ -18,8 +18,8 @@ private[weaver] trait ExpectSame {
         val header     = "Values not equal:"
         val sourceLocs = NonEmptyList.of(loc)
         Expectations(
-          Validated.invalidNel[AssertionException, Unit](
-            new AssertionException(header + "\n\n" + report, sourceLocs)))
+          Validated.invalidNel[ExpectationFailed, Unit](
+            new ExpectationFailed(header + "\n\n" + report, sourceLocs)))
     }
   }
 
diff --git a/modules/core/shared/src/main/scala/weaver/suites.scala b/modules/core/shared/src/main/scala/weaver/suites.scala
index 975ebbf7..b6a384e4 100644
--- a/modules/core/shared/src/main/scala/weaver/suites.scala
+++ b/modules/core/shared/src/main/scala/weaver/suites.scala
@@ -32,18 +32,6 @@ trait EffectSuite[F[_]] extends Suite[F] with EffectSuiteAux with SourceLocation
   implicit protected def effectCompat: EffectCompat[F]
   implicit final protected def effect: Async[F] = effectCompat.effect
 
-  /**
-   * Raise an error that leads to the running test being tagged as "cancelled".
-   */
-  def cancel(reason: String)(implicit pos: SourceLocation): F[Nothing] =
-    effect.raiseError(new CanceledException(Some(reason), pos))
-
-  /**
-   * Raises an error that leads to the running test being tagged as "ignored"
-   */
-  def ignore(reason: String)(implicit pos: SourceLocation): F[Nothing] =
-    effect.raiseError(new IgnoredException(Some(reason), pos))
-
   override def name : String = self.getClass.getName.replace("$", "")
 
   protected def adaptRunError: PartialFunction[Throwable, Throwable] = PartialFunction.empty
@@ -95,11 +83,7 @@ abstract class RunnableSuite[F[_]] extends EffectSuite[F] {
 
 
   private[this] def onlyNotOnCiFailure(test: TestName): TestOutcome = {
-    val result = Result.Failure(
-      msg = "'Only' tag is not allowed when `isCI=true`",
-      source = None,
-      location = List(test.location)
-    )
+    val result = Result.OnlyTagNotAllowedInCI(location = test.location)
     TestOutcome(
       name = test.name,
       duration = FiniteDuration(0, "ns"),
diff --git a/modules/framework-cats/shared/src/test/scala/DogFoodTests.scala b/modules/framework-cats/shared/src/test/scala/DogFoodTests.scala
index dfb49442..59e9d2f4 100644
--- a/modules/framework-cats/shared/src/test/scala/DogFoodTests.scala
+++ b/modules/framework-cats/shared/src/test/scala/DogFoodTests.scala
@@ -234,27 +234,6 @@ object DogFoodTests extends IOSuite {
     }
   }
 
-  test(
-    "cancelled tests with multi-line test name are rendered correctly") {
-    _.runSuite(Meta.Rendering).map {
-      case (logs, _) =>
-        val actual =
-          extractLogEventBeforeFailures(logs) {
-            case LoggedEvent.Info(msg) if msg.contains("(cancelled)") => msg
-          }.get
-
-        val expected = """
-        |- lots 0ms
-        |  of
-        |  multiline
-        |  (cancelled) !!! CANCELLED !!!
-        |  I was cancelled :( (src/main/DogFoodTests.scala:5)
-        """.stripMargin.trim
-
-        expect.same(actual, expected)
-    }
-  }
-
   test(
     "expect.eql delegates to Comparison show when an instance is found") {
     _.runSuite(Meta.Rendering).map {
diff --git a/modules/framework-cats/shared/src/test/scala/Meta.scala b/modules/framework-cats/shared/src/test/scala/Meta.scala
index 5aea4031..e54bbad5 100644
--- a/modules/framework-cats/shared/src/test/scala/Meta.scala
+++ b/modules/framework-cats/shared/src/test/scala/Meta.scala
@@ -73,10 +73,6 @@ object Meta {
       ignore("Ignore me")
     }
 
-    test("lots\nof\nmultiline\n(cancelled)") {
-      cancel("I was cancelled :(")
-    }
-
     import cats.Show
     case class Foo(s: String, i: Int)
     object Foo {
diff --git a/modules/framework/shared/src/main/scala/weaver/framework/SbtEvent.scala b/modules/framework/shared/src/main/scala/weaver/framework/SbtEvent.scala
index 6207fd96..c5a9cafb 100644
--- a/modules/framework/shared/src/main/scala/weaver/framework/SbtEvent.scala
+++ b/modules/framework/shared/src/main/scala/weaver/framework/SbtEvent.scala
@@ -30,7 +30,6 @@ object SbtEvent {
         case TestStatus.Failure   => Status.Failure
         case TestStatus.Success   => Status.Success
         case TestStatus.Ignored   => Status.Ignored
-        case TestStatus.Cancelled => Status.Canceled
       }
 
     def selector(): Selector = {