Per Roland
it’s a bug: upon failing the Supervisor will suspends its children (though not recursively, which is also a bug), and when it is resumed, it will not pass this info on to its children.

A test program modeled after typesafe akka project , with two levels of supervisor added:
Root->Supervisor->Counter
Both Root and Supervisor have a OneForOne strategy that resumes on any exception.
Supervisor and Count throw exception on receipt of a specific message.
Error recovery proceeds as expected, generating a value of 4, IFF the Counter actor is failed at least once before the Supervisor is failed.

Failing only the Supervisor (or before failing the Counter) causes the final Get to timeout.
The Supervisor ceases to forward messages to its child.

The code to fetch the final count has been changed from the template to include a small timeout.

java version "1.7.0_03"
Java(TM) SE Runtime Environment (build 1.7.0_03-b04)
Java HotSpot(TM) 64-Bit Server VM (build 22.1-b02, mixed mode)
Scala 2.9.2
Akka 2.0.1
Fedora 15

Removing the lines marked with "must appear" causes the failure to occur.

import akka.actor._
import akka.pattern.ask
import akka.dispatch.Await
import akka.util.duration._
import akka.util.Timeout
import akka.actor.SupervisorStrategy._

case object Tick
case object Get
case object FailCounter
case object FailSupervisor

trait Resumer extends Actor {
  override val supervisorStrategy = OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) {
    case _ ⇒ Resume
  }
}

class Root extends Resumer {
  val child = context.actorOf(Props[Supervisor], name = "supervisor")

  def receive = {
    case _@ m => child forward m
  }
}

class Supervisor extends Resumer {
   val child = context.actorOf(Props[Counter], name = "counter")

  def receive = {
    case FailSupervisor => throw new IllegalArgumentException("supervisor")
    case _@ m => child forward m
  }
}

class Counter extends Actor {
  var count = 0

  def receive = {
    case Tick => count += 1
    case Get => sender ! count
    case FailCounter => throw new IllegalArgumentException("counter")
  }
}

object Actors extends App {
  val duration = 2 seconds
  implicit val timeout = Timeout(duration)
  val system = ActorSystem("Actors")

  val root = system.actorOf(Props[Root], name = "root")

  root ! Tick
  root ! FailCounter //must appear
  root ! Tick
  root ! FailCounter //must appear
  root ! Tick
  root ! FailSupervisor
  root ! FailCounter
  root ! Tick

  println("count is", Await.result(ask(root, Get).mapTo[Int], duration))

  system.shutdown()
}