anchor.diff:      
     /// creates an async workflow worker, given a message receiver client
     let worker client =
  -      async {
  -        while true do
  -          let! bmsg = timeout |> recv client
  -          if bmsg <> null then
  -            logger.Debug("received message")
  -            messages.Add bmsg
  -          else
  -            () }//logger.Debug("got null msg due to timeout receiving") }
  +    async {
  +      while true do
  +        let! bmsg = timeout |> recv client
  +        if bmsg <> null then
  +          logger.Debug("received message")
  +          messages.Add bmsg
  +        else
  +          () }//logger.Debug("got null msg due to timeout receiving") }
             
     /// cleans out the message buffer and disposes all messages therein
     let clearLocks () =
  
positive.code:           | Pause -> ct.Cancel() ; return! paused state
            | Halt -> ct.Cancel(); return! halted state
            | SubscribeQueue(qd, cc) ->
              let! pairs = initReceiverSet qd newMf cc
              for Pair(mf, rs) in pairs do
                for r in rs do Async.Start(r |> worker, ct.Token)
              let qsubs' = state.QSubs.Add(qd, pairs)
              return! started { QSubs = qsubs' ; TSubs = state.TSubs } ct
            | UnsubscribeQueue qd ->
              (* todo *) return! started state ct
            | SubscribeTopic(td, cc) ->
              (* todo *) return! started state ct
            | UnsubscribeTopic td ->
            (* todo *) return! started state ct
            | _ -> (* ignore Start *) return! started state ct }
  
        and paused state =
  
negative.code:           | x ->
              let entry = sprintf "could not abandon message#%s" <| (!m).MessageId
              logger.Error(entry, x) }
  
    /// Closes the pair of a messaging factory and a list of receivers
    let closePair pair =
      let (Pair(mf, rs)) = pair
      logger.InfoFormat("closing all ({0} of them) receivers and their mf", rs.Length)
      if not(mf.IsClosed) then
        try mf.Close()
        with | x -> logger.Error("could not close messaging factory", x)
      for r in rs do
        if not(r.IsClosed) then
          try r.Close()
          with | x -> logger.Error("could not close receiver", x)
  
    /// An agent that implements the reactor pattern, reacting to messages.
    /// The mutually recursive function 'initial' uses the explicit functional
  