diff --git a/hub/broadcaster-aggregator/src/main/scala/net/shrine/aggregation/ReadPreviousQueriesAggregator.scala b/hub/broadcaster-aggregator/src/main/scala/net/shrine/aggregation/ReadPreviousQueriesAggregator.scala
index 022e0485f..29317ff54 100644
--- a/hub/broadcaster-aggregator/src/main/scala/net/shrine/aggregation/ReadPreviousQueriesAggregator.scala
+++ b/hub/broadcaster-aggregator/src/main/scala/net/shrine/aggregation/ReadPreviousQueriesAggregator.scala
@@ -1,45 +1,46 @@
 package net.shrine.aggregation
 
 import net.shrine.aggregation.BasicAggregator.Valid
 import net.shrine.log.Loggable
 import net.shrine.protocol.{QueryMaster, ShrineResponse, ReadPreviousQueriesResponse}
 
 /**
  * @author Bill Simons
  * @author Clint Gilbert
  * @date 6/8/11
  * @link http://cbmi.med.harvard.edu
  * @link http://chip.org
  *       <p/>
  *       NOTICE: This software comes with NO guarantees whatsoever and is
  *       licensed as Lgpl Open Source
  * @link http://www.gnu.org/licenses/lgpl.html
  */
+//todo remove - likely not used after local/local is in place
 final class ReadPreviousQueriesAggregator extends IgnoresErrorsAggregator[ReadPreviousQueriesResponse] with Loggable {
 
   private[aggregation] def newestToOldest(x: QueryMaster, y: QueryMaster) = x.createDate.compare(y.createDate) > 0
   
   private[aggregation] def oldestToNewest(x: QueryMaster, y: QueryMaster) = x.createDate.compare(y.createDate) < 0
 
   override def makeResponseFrom(responses: Iterable[Valid[ReadPreviousQueriesResponse]]): ShrineResponse = {
     //debug(s"Raw previous query responses: $responses")
     
     val mastersGroupedById = responses.flatMap(_.response.queryMasters).groupBy(_.queryMasterId)
 
     val sortedMastersById = mastersGroupedById.map { case (id, mastersWithThatId) => (id, mastersWithThatId.toSeq.sortWith(oldestToNewest)) }.toMap
 
     val mostRecentMastersForEachId = sortedMastersById.flatMap { case (id, mastersWithThatId) => mastersWithThatId.headOption }.toSeq
 
     val sortedMasters = mostRecentMastersForEachId.sortWith(newestToOldest)
     
     val result = ReadPreviousQueriesResponse(sortedMasters)
     
     debug("Previous queries: ")
     
     sortedMasters.foreach(debug(_))
 
     debug(s"Previous queries result: $result")
 
     result
   }
 }
\ No newline at end of file
diff --git a/qep/service/src/main/scala/net/shrine/service/I2b2BroadcastService.scala b/qep/service/src/main/scala/net/shrine/service/I2b2BroadcastService.scala
index 280487533..a65593565 100644
--- a/qep/service/src/main/scala/net/shrine/service/I2b2BroadcastService.scala
+++ b/qep/service/src/main/scala/net/shrine/service/I2b2BroadcastService.scala
@@ -1,73 +1,62 @@
 package net.shrine.service
 
 import net.shrine.protocol.I2b2RequestHandler
 import net.shrine.protocol.DeleteQueryRequest
-import net.shrine.aggregation.ReadPreviousQueriesAggregator
-import net.shrine.aggregation.DeleteQueryAggregator
-import net.shrine.aggregation.ReadTranslatedQueryDefinitionAggregator
-import net.shrine.aggregation.ReadQueryResultAggregator
-import net.shrine.aggregation.ReadPdoResponseAggregator
-import net.shrine.aggregation.ReadQueryDefinitionAggregator
-import net.shrine.aggregation.RenameQueryAggregator
-import net.shrine.aggregation.ReadInstanceResultsAggregator
-import net.shrine.protocol.BaseShrineResponse
 import net.shrine.protocol.ReadApprovedQueryTopicsRequest
 import net.shrine.protocol.ReadInstanceResultsRequest
 import net.shrine.protocol.ReadPreviousQueriesRequest
 import net.shrine.protocol.RenameQueryRequest
 import net.shrine.protocol.RunQueryRequest
 import net.shrine.protocol.ReadPdoRequest
 import net.shrine.protocol.ReadQueryDefinitionRequest
 import net.shrine.protocol.ReadQueryInstancesRequest
-import net.shrine.protocol.ReadQueryResultRequest
 import net.shrine.protocol.ShrineResponse
 import net.shrine.service.dao.AuditDao
 import net.shrine.authentication.Authenticator
 import net.shrine.authorization.QueryAuthorizationService
 import net.shrine.broadcaster.BroadcastAndAggregationService
 import scala.concurrent.duration.Duration
 import net.shrine.protocol.FlagQueryRequest
-import net.shrine.aggregation.FlagQueryAggregator
 import net.shrine.protocol.UnFlagQueryRequest
 import net.shrine.protocol.ReadResultOutputTypesRequest
 import net.shrine.protocol.ResultOutputType
 
 /**
  * @author clint
  * @since Feb 19, 2014
  */
 final case class I2b2BroadcastService(
     commonName:String,
     auditDao: AuditDao,
     authenticator: Authenticator,
     authorizationService: QueryAuthorizationService,
     includeAggregateResult: Boolean,
     broadcastAndAggregationService: BroadcastAndAggregationService,
     queryTimeout: Duration,
     breakdownTypes: Set[ResultOutputType],
     collectQepAudit:Boolean) extends AbstractShrineService[ShrineResponse] with I2b2RequestHandler {
 
   override def readResultOutputTypes(request: ReadResultOutputTypesRequest): ShrineResponse = doReadResultOutputTypes(request)
   
   override def runQuery(request: RunQueryRequest, shouldBroadcast: Boolean): ShrineResponse = doRunQuery(request, shouldBroadcast)
 
   override def readQueryDefinition(request: ReadQueryDefinitionRequest, shouldBroadcast: Boolean) = doReadQueryDefinition(request, shouldBroadcast)
 
   override def readPdo(request: ReadPdoRequest, shouldBroadcast: Boolean) = doReadPdo(request, shouldBroadcast)
 
   override def readInstanceResults(request: ReadInstanceResultsRequest, shouldBroadcast: Boolean) = doReadInstanceResults(request, shouldBroadcast)
 
   override def readQueryInstances(request: ReadQueryInstancesRequest, shouldBroadcast: Boolean) = doReadQueryInstances(request, shouldBroadcast)
 
   override def readPreviousQueries(request: ReadPreviousQueriesRequest, shouldBroadcast: Boolean) = doReadPreviousQueries(request, shouldBroadcast)
 
   override def renameQuery(request: RenameQueryRequest, shouldBroadcast: Boolean) = doRenameQuery(request, shouldBroadcast)
 
   override def deleteQuery(request: DeleteQueryRequest, shouldBroadcast: Boolean) = doDeleteQuery(request, shouldBroadcast)
 
   override def readApprovedQueryTopics(request: ReadApprovedQueryTopicsRequest, shouldBroadcast: Boolean) = doReadApprovedQueryTopics(request, shouldBroadcast)
   
   override def flagQuery(request: FlagQueryRequest, shouldBroadcast: Boolean = true) = doFlagQuery(request, shouldBroadcast)
   
   override def unFlagQuery(request: UnFlagQueryRequest, shouldBroadcast: Boolean = true) = doUnFlagQuery(request, shouldBroadcast)
 }
\ No newline at end of file