Consider what happens when we resolve a two-object action, such as "put <dobj> in <iobj>". Since we have two objects, we obviously must resolve one object or the other first; but this means that we must resolve one object with no knowledge of the resolution of the other object. This often makes it very difficult to resolve that first object intelligently, because we'd really like to know something about the other object. For example, if we first resolve the iobj of "put <dobj> in <iobj>", it would be nice to know which dobj we're talking about, since we could reduce the likelihood that the iobj is the dobj's present container.
Tentative resolution addresses this need by giving us some information about a later-resolved object while resolving an earlier-resolved object, even though we obviously can't have fully resolved the later-resolved object. In tentative resolution, we perform the resolution of the later-resolved object, completely in the dark about the earlier-resolved object(s), and come up with as much information as we can. The important thing about this stage of resolution is that we don't ask any interactive questions and we don't count anything for ranking purposes - we simply do the best we can and note the results, leaving any ranking or interaction for the true resolution phase that we'll perform later.
TentativeResolveResults : ResolveResults