anchor.diff:      while true do
         let! req = inbox.Receive()
         match req with
  +      | ProposeCandidates (constraints, (p, cs), lockedPackages, channel) ->
  +        lockedPackages
  +        |> AsyncSeq.ofSeq
  +        |> AsyncSeq.mapAsync(fun lp -> async {
  +          try
  +            let! manifest = sourceExplorer.FetchManifest (lp.Location, lp.Versions)
  +
  +            let conflicts =
  +              manifest.Dependencies
  +              |> Set.map toPackageConstraint
  +              |> constraintsOf
  +              |> Map.insertWith Set.union p cs
  +              |> findBadCores
  +              |> Seq.map TransitiveConflict
  +
  +            if conflicts |> Seq.isEmpty
  +            then
  +              return Result.Error NoManifest // TODO ...
  +            else
  +              let rv: ResolvedVersion = {
  +                Manifest = manifest
  +                Lock = lp.Location
  +                Versions = lp.Versions
  +              }
  +              return Result.Ok rv
  +          with _ ->
  +            return Result.Error NoManifest
  +        })
  +        |> AsyncSeq.filter (fun x ->
  +          match x with
  +          | Result.Error _ -> false
  +          | _ -> true)
  +        |> AsyncSeq.takeWhile(fun e ->
  +          match e with
  +          | _ -> findBadCores constraints |> Seq.isEmpty)
  +        |> channel.Reply
  +
         | GetCandidates (constraints, dep, locations, channel) ->
           trackLocal locations dep
           |> AsyncSeq.takeWhile(fun e ->
  
positive.code:     state.Hints
      |> Map.tryFind p
      |> Option.defaultValue []
      |> List.map (fun l -> l.PrivatePackages |> Map.toSeq)
      |> Seq.collect id
      |> Seq.groupBy fst
      |> Seq.map (fun (k, vs) -> (k, vs |> Seq.map snd |> Seq.distinct |> Seq.map List.singleton |> List.concat))
  
negative.code:           channel.Reply ()
    })
  
    let getHints (resolver: MailboxProcessor<ResolutionRequest>) state selections p cs = asyncSeq {
  
      let constraints =
        selections
        |> Map.valueList
        |> Seq.map fst
        |> Seq.map (fun m -> m.Manifest.Dependencies)
        |> Seq.append [state.Root]
        |> Seq.map (Set.map toPackageConstraint)
        |> Set.unionMany
        |> constraintsOf
  
      let c = cs |> All
      let candidates =
        state.Hints
        |> Map.tryFind p
        |> Option.defaultValue([])
        |> Seq.filter(fun lp -> lp.Versions |> Constraint.satisfies c)
        |> Seq.distinct
  
  
      let! request = resolver.PostAndAsyncReply (fun channel -> ProposeCandidates (constraints, (p, cs), candidates, channel))
      yield! request
    }
  
    let fetchHints (sourceExplorer : ISourceExplorer) (state: SolverState) (resolvedVersion : ResolvedVersion) : Async<SolverState> = async {
      try
  