                           (instance? Throwable srvr-state)
                           (nil? srvr-state))
                   (is (not srvr-state)))
+                ;; Keep this around as a reminder to look carefully at it in
+                ;; case of wonkiness
                 (comment (is (not flow-control) "Server flow-control")))
               (is (= ::kthxbai really-succeeded?))
               (is (= 6 (-> client-state
                            deref
                            ::count)))))
           (finally
-            (log/info "Cleaning up")
+            (swap! log-atom
+                   log/info
+                   ::handshake-status-check
+                   "Cleaning up")
             (strm/close! clnt-decode-src)
             (strm/close! srvr-decode-src)
             (try
               (message/halt! client-io)
               (catch Exception ex
-                (log/error ex "Trying to halt client")))
+                (swap! log-atom
+                       log/exception
+                       ex
+                       ::handshake-status-check
+                       "Trying to halt client")))
             (try
               (message/halt! server-io)
               (catch Exception ex
-                (log/error ex "Trying to halt server")))))))))
+                (swap! log-atom
+                       log/exception
+                       ex
+                       ::handshake-status-check
+                       "Trying to halt server")))
+            (log/flush-logs! logger @log-atom)))))))
 (comment
   (handshake)
   (count (str ::kk))

(defn consumer
  [{:keys [::specs/message-loop-name]
    :as io-handle}
   prelog time-out succeeded? bs]
  ;; Note that, at this point, we're blocking the
  ;; I/O loop.
  ;; Whatever happens here must return control

                      ;; Q: But is it worth it for the test's sake?
                      ;; Better Q: Is this the sort of thing that will trip
                      ;; us up with surprising behavior if it doesn't work?
                      (let [state (message/get-state io-handle time-out ::timed-out)]
                        (swap! log-atom
                               log/debug
                               log-ctx
                               "Got state"
                               {::state state
                                ::parent-context prelog})
                        (if (or (= ::timed-out state)
                                (instance? Throwable state)
                                (nil? state))
