Thinking about this a bit more, the semantics of the `check-for-errors!` function doesn't quite seem right.  Instead, I was thinking about the possibility of splitting this into two functions on the App interface:

* `shutdown-requested?` - called implicitly during `init` or `start` or could be called at any time later on to determine if an app shutdown has been requested.  The ability to call it later on could be helpful in the reloaded repl for diagnosing a shutdown request that occurs after the `start` phase has completed -- i.e., from an asynchronous worker thread.

* `get-shutdown-reason` - Gets the shutdown reason map -- nil if no shutdown reason has been set yet.  Useful for getting more details on why the shutdown was requested, if the caller is interested.

I played around with this using a mocked up form of the ring_app repl.clj from the Jetty9 project.  The code looked like this:

```clj
(def system nil)

(defn shutdown-requested? []
  (tka/shutdown-requested? system))

(defn shutdown-reason []
  (tka/get-shutdown-reason system))

(defn print-shutdown-reason []
  (clojure.pprint/pprint (shutdown-reason)))

(defn do-phase [f]
  (when-let [app (alter-var-root #'system f)]
    (if (shutdown-requested?)
      (print-shutdown-reason))
    app))

(defn init []
  (alter-var-root #'system
                  (fn [_] (tk/build-app
                           [jetty9-service count-service bert-service ernie-service]
                           {:global    {:logging-config
                                         "examples/ring_app/logback.xml"}
                            :webserver {:port 8080 }
                            :example   {:ernie-url-prefix
                                         "/ernie"}})))
  (do-phase tka/init))

(defn start []
  (do-phase (fn [s] (if s (tka/start s)))))

(defn stop []
  (alter-var-root #'system
    (fn [s] (if s (tka/stop s)))))

(defn go []
  (init)
  (if (shutdown-requested?)
    system
    (start)))

(defn context []
  @(tka/app-context system))

(defn print-context []
  (clojure.pprint/pprint (context)))

(defn reset []
  (stop)
  (refresh :after 'examples.ring-app.repl/go))
```

I know this is significantly longer than what we have today but it still seems relatively straightforward to me and could be useful for detecting / analyzing all of the different flavors of shutdowns that an app might request -- `shutdown-on-error` or `request-shutdown` whether synchronous or asynchronous to the bootstrap process on the main thread.

What would you think of going this direction?