Implement dependency configuration negotiation

For the detailed history see the dep-config and dep-config-neg branches.

179 files changed, 17434 insertions, 1093 deletions

diff --git a/bpkg/auth.cxx b/bpkg/auth.cxx
index 85cf5fa..663054d 100644
--- a/bpkg/auth.cxx
+++ b/bpkg/auth.cxx
@@ -7,7 +7,6 @@
 #include <limits>   // numeric_limits
 #include <iterator> // ostreambuf_iterator
 
-#include <libbutl/sha256.hxx>
 #include <libbutl/base64.hxx>
 #include <libbutl/openssl.hxx>
 #include <libbutl/timestamp.hxx>
diff --git a/bpkg/checksum.cxx b/bpkg/checksum.cxx
index 65ed377..b761d0b 100644
--- a/bpkg/checksum.cxx
+++ b/bpkg/checksum.cxx
@@ -331,7 +331,7 @@ namespace bpkg
   }
 
   string
-  sha256 (const common_options& o, const path& f)
+  sha256sum (const common_options& o, const path& f)
   {
     if (!exists (f))
       fail << "file " << f << " does not exist";
diff --git a/bpkg/checksum.hxx b/bpkg/checksum.hxx
index 73f52e8..54e5b3c 100644
--- a/bpkg/checksum.hxx
+++ b/bpkg/checksum.hxx
@@ -4,8 +4,6 @@
 #ifndef BPKG_CHECKSUM_HXX
 #define BPKG_CHECKSUM_HXX
 
-#include <libbutl/sha256.hxx>
-
 #include <bpkg/types.hxx>
 #include <bpkg/utility.hxx>
 
@@ -16,7 +14,7 @@ namespace bpkg
   // Calculate SHA256 sum of the specified memory buffer in binary mode.
   //
   inline string
-  sha256 (const char* buf, size_t n) {return butl::sha256 (buf, n).string ();}
+  sha256sum (const char* buf, size_t n) {return sha256 (buf, n).string ();}
 
   // The same but for a file. Issue diagnostics and throw failed if anything
   // goes wrong.
@@ -26,7 +24,7 @@ namespace bpkg
   // optimized for the platform.
   //
   string
-  sha256 (const common_options&, const path& file);
+  sha256sum (const common_options&, const path& file);
 }
 
 #endif // BPKG_CHECKSUM_HXX
diff --git a/bpkg/database.cxx b/bpkg/database.cxx
index b0a673e..d96c53b 100644
--- a/bpkg/database.cxx
+++ b/bpkg/database.cxx
@@ -10,8 +10,6 @@
 #include <odb/schema-catalog.hxx>
 #include <odb/sqlite/exceptions.hxx>
 
-#include <libbutl/sha256.hxx>
-
 #include <bpkg/package.hxx>
 #include <bpkg/package-odb.hxx>
 #include <bpkg/diagnostics.hxx>
@@ -706,7 +704,7 @@ namespace bpkg
       //
       std::string schema;
       {
-        butl::sha256 h (d.string ());
+        sha256 h (d.string ());
 
         for (size_t n (4);; ++n)
         {
diff --git a/bpkg/fetch-pkg.cxx b/bpkg/fetch-pkg.cxx
index 64abb43..ca4767f 100644
--- a/bpkg/fetch-pkg.cxx
+++ b/bpkg/fetch-pkg.cxx
@@ -52,7 +52,7 @@ namespace bpkg
       is.close ();
 
       string s (bs.str ());
-      string sha256sum (sha256 (s.c_str (), s.size ()));
+      string cs (sha256sum (s.c_str (), s.size ()));
 
       istringstream ts (s); // Text mode.
 
@@ -60,7 +60,7 @@ namespace bpkg
       M m (mp, ignore_unknown);
 
       if (pr.wait ())
-        return make_pair (move (m), move (sha256sum));
+        return make_pair (move (m), move (cs));
 
       // Child existed with an error, fall through.
     }
@@ -146,14 +146,14 @@ namespace bpkg
       // and reading the manifest. The file should be opened in the binary
       // mode for the first operation and in the text mode for the second one.
       //
-      string sha256sum;
+      string cs;
       if (o != nullptr)
-        sha256sum = sha256 (*o, f); // Read file in the binary mode.
+        cs = sha256sum (*o, f); // Read file in the binary mode.
 
       ifdstream ifs (f);  // Open file in the text mode.
 
       manifest_parser mp (ifs, f.string ());
-      return make_pair (M (mp, ignore_unknown), move (sha256sum));
+      return make_pair (M (mp, ignore_unknown), move (cs));
     }
     catch (const manifest_parsing& e)
     {
diff --git a/bpkg/manifest-utility.cxx b/bpkg/manifest-utility.cxx
index f690a40..d205c2d 100644
--- a/bpkg/manifest-utility.cxx
+++ b/bpkg/manifest-utility.cxx
@@ -6,7 +6,6 @@
 #include <cstring> // strcspn()
 
 #include <libbutl/b.hxx>
-#include <libbutl/sha256.hxx>
 
 #include <bpkg/package.hxx>        // wildcard_version
 #include <bpkg/diagnostics.hxx>
diff --git a/bpkg/package-configuration.cxx b/bpkg/package-configuration.cxx
new file mode 100644
index 0000000..e8ea13a
--- /dev/null
+++ b/bpkg/package-configuration.cxx
@@ -0,0 +1,491 @@
+// file      : bpkg/package-configuration.cxx -*- C++ -*-
+// license   : MIT; see accompanying LICENSE file
+
+#include <bpkg/package-configuration.hxx>
+
+#include <sstream>
+
+#include <bpkg/package-skeleton.hxx>
+
+namespace bpkg
+{
+  using build2::config::variable_origin;
+
+  string
+  serialize_cmdline (const string& name, const optional<build2::names>& value)
+  {
+    using namespace build2;
+
+    string r (name + '=');
+
+    if (!value)
+      r += "[null]";
+    else
+    {
+      if (!value->empty ())
+      {
+        // Note: we need to use command-line (effective) quoting.
+        //
+        ostringstream os;
+        to_stream (os, *value, quote_mode::effective, '@');
+        r += os.str ();
+      }
+    }
+
+    return r;
+  }
+
+  void package_configuration::
+  print (diag_record& dr,
+         const char* indent,
+         const dependent_config_variable_values* ovrs) const
+  {
+    bool first (true);
+    for (const config_variable_value& v: *this)
+    {
+      if (v.origin != variable_origin::buildfile &&
+          v.origin != variable_origin::override_)
+        continue;
+
+      if (first)
+        first = false;
+      else
+        dr << '\n';
+
+      dr << indent;
+
+      if (ovrs != nullptr && v.origin == variable_origin::buildfile)
+      {
+        if (const dependent_config_variable_value* ov = ovrs->find (v.name))
+        {
+          dr << ov->serialize_cmdline () << " (set by " << ov->dependent << ')';
+          continue;
+        }
+      }
+
+      dr << v.serialize_cmdline () << " (";
+
+      if (v.origin == variable_origin::buildfile)
+        dr << "set by " << *v.dependent;
+      else
+        dr << "user configuration";
+
+      dr << ')';
+    }
+  }
+
+  void
+  to_checksum (sha256& cs, const config_variable_value& v)
+  {
+    using namespace build2;
+
+    cs.append (v.name);
+    cs.append (static_cast<uint8_t> (v.origin));
+    if (v.type)
+      cs.append (*v.type);
+
+    if (v.origin != variable_origin::undefined)
+    {
+      if (v.value)
+        for (const name& n: *v.value)
+          to_checksum (cs, n);
+
+      if (v.origin == variable_origin::buildfile)
+      {
+        cs.append (v.dependent->string ());
+        cs.append (v.confirmed);
+      }
+    }
+  }
+
+  bool
+  negotiate_configuration (
+    package_configurations& cfgs,
+    package_skeleton& dept,
+    pair<size_t, size_t> pos,
+    const small_vector<reference_wrapper<package_skeleton>, 1>& depcs)
+  {
+    assert (!dept.system);
+
+    pos.first--; pos.second--; // Convert to 0-base.
+
+    const dependency_alternative& da (
+      dept.available->dependencies[pos.first][pos.second]);
+
+    assert (da.require || da.prefer);
+
+    // Step 1: save a snapshot of the old configuration while unsetting values
+    // that have this dependent as the originator and reloading the defaults.
+    //
+    // The idea behind unsetting values previously (first) set by this
+    // dependent is to allow it to "change its mind" based on other changes in
+    // the configuration (e.g., some expensive feature got enabled by another
+    // dependent which this dependent might as well use).
+    //
+    // This works well if the default values of configuration variables are
+    // independent. However, consider this example:
+    //
+    // dependency:
+    //
+    //   config [bool] config.foo.x ?= false
+    //   config [bool] config.foo.buf ?= ($config.foo.x ? 8196 : 4096)
+    //
+    // dependent:
+    //
+    //   config.foo.x = true
+    //   config.foo.buf = ($config.foo.buf < 6144 ? 6144 : $config.foo.buf)
+    //
+    // Here if we unset both x and buf to their defaults, we will get an
+    // incorrect result.
+    //
+    // The long-term solution here is to track dependencies between
+    // configuration variables (which we can do as part of the config
+    // directive via our parser::lookup_variable() hook and save this
+    // information in the config module's saved_variables list). Then, we
+    // "levelize" all the variables and have an inner "refinement" loop over
+    // these levels. Specifically, we first unset all of them. Then we unset
+    // all except the first level (which contains configuration variables that
+    // don't depend on any others). And so on.
+    //
+    // And until we implement this, we expect the dependent to take such
+    // configuration variable dependencies into account. For example:
+    //
+    // config.foo.x = true
+    // config.foo.buf = ($config.foo.buf < 6144
+    //                   ? ($config.foo.x ? 8196 : 6144)
+    //                   : $config.foo.buf)
+    //
+    // Another issue with this "originating dependent" logic is that it will
+    // be tricky to scale to containers where we would need to track
+    // originating dependents for individual elements of a value rather than
+    // the whole value as we do now. As an example, consider some "set of
+    // enabled backends" configuration variable. Technically, this doesn't
+    // seem insurmountable if we make some assumptions (e.g., if a value
+    // contains multiple elements, then it is such a set-like value; or
+    // we could use actual type names).
+    //
+    // For now we recommend to use multiple bool configurations to handle such
+    // cases (and, in fact, we currently don't have any set/map-like types,
+    // which we may want to add in the future). However, one could come up
+    // with some open-ended configuration list that will be difficult to
+    // support with bool. For example, we may need to support a set of buffer
+    // sizes or some such.
+    //
+    // Our assumptions regarding require:
+    //
+    // - Can only set bool configuration variables and only to true.
+    //
+    // - Should not have any conditions on the state of other configuration
+    //   variables, including their origin (but can have other conditions,
+    //   for example on the target platform).
+    //
+    // This means that we don't need to set the default values, but will need
+    // the type information as well as overrides. So what we will do is only
+    // call reload_defaults() for the first time to load types/override. Note
+    // that this assumes the set of configuration variables cannot change
+    // based on the values of other configuration variables (we have a note
+    // in the manual instructing the user not to do this).
+    //
+    // The dependency could also be system in which case there could be no
+    // skeleton information to load the types/defaults from. In this case we
+    // can handle require in the "lax mode" (based on the above assumptions)
+    // but not prefer.
+    //
+    // While at it, also collect the configurations to pass to dependent's
+    // evaluate_*() calls.
+    //
+    dependent_config_variable_values old_cfgs;
+    package_skeleton::dependency_configurations depc_cfgs;
+    depc_cfgs.reserve (depcs.size ());
+
+    for (package_skeleton& depc: depcs)
+    {
+      package_configuration& cfg (cfgs[depc.package]);
+
+      for (config_variable_value& v: cfg)
+      {
+        if (v.origin == variable_origin::buildfile)
+        {
+          if (*v.dependent == dept.package)
+          {
+            old_cfgs.push_back (
+              dependent_config_variable_value {
+                v.name, move (v.value), move (*v.dependent)});
+
+            // Note that we will not reload it to default in case of require.
+            //
+            v.undefine ();
+          }
+          else
+            old_cfgs.push_back (
+              dependent_config_variable_value {v.name, v.value, *v.dependent});
+        }
+      }
+
+      if (depc.available == nullptr)
+      {
+        assert (depc.system);
+
+        if (da.prefer)
+          fail << "unable to negotiate configuration for system dependency "
+               << depc.package << " without configuration information" <<
+            info << "consider specifying system dependency version that has "
+               << "corresponding available package" <<
+            info << "dependent " << dept.package << " has prefer/accept clauses "
+               << "that cannot be evaluated without configuration information";
+
+        if (!cfg.system)
+        {
+          // Note that we still need the overrides.
+          //
+          depc.load_overrides (cfg);
+          cfg.system = true;
+        }
+
+        continue;
+      }
+      else
+        assert (!cfg.system);
+
+      if (da.prefer || cfg.empty ())
+        depc.reload_defaults (cfg);
+    }
+
+    // Note that we need to collect the dependency configurations as a
+    // separate loop so that the stored references are not invalidated by
+    // operator[] (which is really a push_back() into a vector).
+    //
+    for (package_skeleton& depc: depcs)
+      depc_cfgs.push_back (cfgs[depc.package]);
+
+    // Step 2: execute the prefer/accept or requires clauses.
+    //
+    if (!(da.require
+          ? dept.evaluate_require (depc_cfgs, *da.require, pos)
+          : dept.evaluate_prefer_accept (depc_cfgs,
+                                         *da.prefer, *da.accept, pos)))
+    {
+      diag_record dr (fail);
+
+      dr << "unable to negotiate acceptable configuration with dependent "
+         << dept.package << " for dependencies ";
+
+      for (size_t i (0); i != depcs.size (); ++i)
+        dr << (i == 0 ? "" : ", ") << depcs[i].get ().package;
+
+      dr << info << "configuration before negotiation:\n";
+
+      // Note that we won't print this dependent's values (which we have unset
+      // above), but that seems like a good thing since they are not the cause
+      // of this impasse.
+      //
+      for (const package_configuration& cfg: depc_cfgs)
+        cfg.print (dr, "    "); // Note 4 spaces since in nested info.
+    }
+
+    // Check if anything changed by comparing to entries in old_cfgs.
+    //
+    // While at it, also detect if we have any changes where one dependent
+    // overrides a value set by another dependent (see below).
+    //
+    bool cycle (false);
+    {
+      optional<size_t> n (0); // Number of unchanged.
+
+      for (package_skeleton& depc: depcs)
+      {
+        package_configuration& cfg (cfgs[depc.package]);
+
+        for (config_variable_value& v: cfg)
+        {
+          if (v.origin == variable_origin::buildfile)
+          {
+            if (const dependent_config_variable_value* ov =
+                  old_cfgs.find (v.name))
+            {
+              if (ov->value == v.value)
+              {
+                // If the value hasn't change, so shouldn't the originating
+                // dependent.
+                //
+                assert (ov->dependent == *v.dependent);
+
+                if (n)
+                  ++*n;
+
+                continue;
+              }
+              else
+              {
+                // Note that it's possible the same dependent overrides its
+                // old value (e.g., because a conditional default changed to a
+                // better value).
+                //
+                if (ov->dependent != *v.dependent)
+                  cycle = true;
+              }
+            }
+
+            n = nullopt;
+
+            if (cycle)
+              break;
+          }
+        }
+
+        if (!n && cycle)
+          break;
+      }
+
+      // If we haven't seen any changed and we've seen the same number, then
+      // nothing has changed.
+      //
+      if (n && *n == old_cfgs.size ())
+        return false;
+    }
+
+    // Besides the dependent returning false from its accept clause, there is
+    // another manifestation of the inability to negotiate an acceptable
+    // configuration: two dependents keep changing the same configuration to
+    // mutually unacceptable values. To detect this, we need to look for
+    // negotiation cycles.
+    //
+    // Specifically, given a linear change history in the form:
+    //
+    //   O->N ... O->N ... O->N
+    //
+    // We need to look for a possibility of turning it into a cycle:
+    //
+    //   O->N ... O->N
+    //    \   ...   /
+    //
+    // Where O->N is a change that involves one dependent overriding a value
+    // set by another dependent and `...` are identical history segments.
+    //
+    if (!cycle)
+      return true;
+
+    // Populate new_cfgs.
+    //
+    dependent_config_variable_values new_cfgs;
+    for (package_skeleton& depc: depcs)
+    {
+      package_configuration& cfg (cfgs[depc.package]);
+
+      for (config_variable_value& v: cfg)
+      {
+        if (v.origin == variable_origin::buildfile)
+        {
+          new_cfgs.push_back (
+            dependent_config_variable_value {v.name, v.value, *v.dependent});
+        }
+      }
+    }
+
+    // Sort both.
+    //
+    {
+      auto cmp = [] (const dependent_config_variable_value& x,
+                     const dependent_config_variable_value& y)
+      {
+        return x.name < y.name;
+      };
+
+      sort (old_cfgs.begin (), old_cfgs.end (), cmp);
+      sort (new_cfgs.begin (), new_cfgs.end (), cmp);
+    }
+
+    // Look backwards for identical O->N changes and see if we can come
+    // up with two identical segments between them.
+    //
+    cycle = false;
+
+    auto& change_history (cfgs.change_history_);
+
+    for (size_t n (change_history.size ()), i (n); i != 0; i -= 2)
+    {
+      if (change_history[i - 2] == old_cfgs &&
+          change_history[i - 1] == new_cfgs)
+      {
+        size_t d (n - i); // Segment length.
+
+        // See if there is an identical segment before this that also starts
+        // with O->N.
+        //
+        if (i < 2 + d + 2)
+          break; // Not long enough to possibly find anything.
+
+        size_t j (i - 2 - d); // Earlier O->N.
+
+        if (change_history[j - 2] == old_cfgs &&
+            change_history[j - 1] == new_cfgs)
+        {
+          if (equal (change_history.begin () + j,
+                     change_history.begin () + j + d,
+                     change_history.begin () + i))
+          {
+            cycle = true;
+            break;
+          }
+        }
+
+        // Otherwise, keep looking for a potentially longer segment.
+      }
+    }
+
+    if (!cycle)
+    {
+      change_history.push_back (move (old_cfgs));
+      change_history.push_back (move (new_cfgs));
+
+      return true;
+    }
+
+    diag_record dr (fail);
+
+    dr << "unable to negotiate acceptable configuration between dependents "
+       << dept.package;
+
+    // Analyze the O->N changes and determine the problematic dependent(s).
+    // Do we actually know for sure they are all problematic? Well, they
+    // repeatedly changed the values to the ones we don't like, so I guess so.
+    //
+    small_vector<reference_wrapper<const package_key>, 1> depts; // Duplicates.
+    for (const dependent_config_variable_value& nv: new_cfgs)
+    {
+      if (nv.dependent == dept.package)
+      {
+        if (const dependent_config_variable_value* ov = old_cfgs.find (nv.name))
+        {
+          if (ov->value != nv.value && ov->dependent != nv.dependent)
+          {
+            if (find_if (depts.begin (), depts.end (),
+                         [ov] (reference_wrapper<const package_key> pk)
+                         {
+                           return ov->dependent == pk.get ();
+                         }) == depts.end ())
+            {
+              dr << ", " << ov->dependent;
+              depts.push_back (ov->dependent);
+            }
+          }
+        }
+      }
+    }
+
+    dr << " for dependencies ";
+
+    for (size_t i (0); i != depcs.size (); ++i)
+      dr << (i == 0 ? "" : ", ") << depcs[i].get ().package;
+
+    dr << info << "configuration before negotiation:\n";
+    for (const package_configuration& cfg: depc_cfgs)
+      cfg.print (dr, "    ", &old_cfgs);
+
+    dr << info << "configuration after negotiation:\n";
+    for (const package_configuration& cfg: depc_cfgs)
+      cfg.print (dr, "    ");
+
+    dr << endf;
+  }
+}
diff --git a/bpkg/package-configuration.hxx b/bpkg/package-configuration.hxx
new file mode 100644
index 0000000..73f05ff
--- /dev/null
+++ b/bpkg/package-configuration.hxx
@@ -0,0 +1,206 @@
+// file      : bpkg/package-configuration.hxx -*- C++ -*-
+// license   : MIT; see accompanying LICENSE file
+
+#ifndef BPKG_PACKAGE_CONFIGURATION_HXX
+#define BPKG_PACKAGE_CONFIGURATION_HXX
+
+#include <libbuild2/types.hxx>        // build2::names
+#include <libbuild2/config/types.hxx> // build2::config::variable_origin
+
+#include <bpkg/types.hxx>
+#include <bpkg/utility.hxx>
+
+#include <bpkg/package.hxx>
+
+using namespace std;
+
+namespace bpkg
+{
+  class package_skeleton;
+
+  // Serialize the variable value as a command line override.
+  //
+  string
+  serialize_cmdline (const string& name, const optional<build2::names>& value);
+
+  struct config_variable_value
+  {
+    string name;
+
+    // The variable_origin values have the following meaning:
+    //
+    // default    -- default value from the config directive
+    // buildfile  -- dependent configuration (config_source::dependent)
+    // override   -- user configuration      (config_source::user)
+    // undefined  -- none of the above
+    //
+    build2::config::variable_origin origin;
+
+    // Variable type name with absent signifying untyped.
+    //
+    optional<string> type;
+
+    // If origin is not undefined, then this is the reversed variable value
+    // with absent signifying NULL.
+    //
+    optional<build2::names> value;
+
+    // If origin is buildfile, then this is the "originating dependent" which
+    // first set this variable to this value.
+    //
+    optional<package_key> dependent;
+
+    // If origin is buildfile, then this flag indicates whether the
+    // originating dependent has been encountered during the negotiation
+    // retry.
+    //
+    bool confirmed;
+
+  public:
+    void
+    undefine ()
+    {
+      origin = build2::config::variable_origin::undefined;
+      value = nullopt;
+      dependent = nullopt;
+      confirmed = false;
+    }
+
+    string
+    serialize_cmdline () const
+    {
+      return bpkg::serialize_cmdline (name, value);
+    }
+  };
+
+  void
+  to_checksum (sha256&, const config_variable_value&);
+
+  // A subset of config_variable_value for variable values set by the
+  // dependents (origin is buildfile). Used to track change history.
+  //
+  struct dependent_config_variable_value
+  {
+    string                  name;
+    optional<build2::names> value;
+    package_key             dependent;
+
+  public:
+    string
+    serialize_cmdline () const
+    {
+      return bpkg::serialize_cmdline (name, value);
+    }
+  };
+
+  inline bool
+  operator== (const dependent_config_variable_value& x,
+              const dependent_config_variable_value& y)
+  {
+    return x.name == y.name && x.value == y.value && x.dependent == y.dependent;
+  }
+
+  class dependent_config_variable_values:
+    public small_vector<dependent_config_variable_value, 1>
+  {
+  public:
+    const dependent_config_variable_value*
+    find (const string& name) const
+    {
+      auto i (find_if (begin (), end (),
+                       [&name] (const dependent_config_variable_value& v)
+                       {
+                         return v.name == name;
+                       }));
+      return i != end () ? &*i : nullptr;
+    }
+  };
+
+  class package_configuration: public vector<config_variable_value>
+  {
+  public:
+    package_key package;
+    bool system = false; // True if system package without skeleton info.
+
+    explicit
+    package_configuration (package_key p): package (move (p)) {}
+
+    config_variable_value*
+    find (const string& name)
+    {
+      auto i (find_if (begin (), end (),
+                       [&name] (const config_variable_value& v)
+                       {
+                         return v.name == name;
+                       }));
+      return i != end () ? &*i : nullptr;
+    }
+
+    const config_variable_value*
+    find (const string& name) const
+    {
+      auto i (find_if (begin (), end (),
+                       [&name] (const config_variable_value& v)
+                       {
+                         return v.name == name;
+                       }));
+      return i != end () ? &*i : nullptr;
+    }
+
+    // Print buildfile and override configuration variable values as command
+    // line overrides one per line with the specified indentation. After each
+    // variable also print in parenthesis its origin. If overrides is not
+    // NULL, then it is used to override the value/dependent information.
+    //
+    void
+    print (diag_record&, const char* indent,
+           const dependent_config_variable_values* overrides = nullptr) const;
+  };
+
+  class package_configurations: public small_vector<package_configuration, 1>
+  {
+  public:
+    // Note: may invalidate references.
+    //
+    package_configuration&
+    operator[] (const package_key& p)
+    {
+      auto i (find_if (begin (), end (),
+                       [&p] (const package_configuration& pc)
+                       {
+                         return pc.package == p;
+                       }));
+      if (i != end ())
+        return *i;
+
+      push_back (package_configuration (p));
+      return back ();
+    }
+
+    void
+    clear ()
+    {
+      small_vector<package_configuration, 1>::clear ();
+      change_history_.clear ();
+    }
+
+    // Implementation details.
+    //
+  public:
+    // Note: dependent_config_variable_values must be sorted by name.
+    //
+    small_vector<dependent_config_variable_values, 2> change_history_;
+  };
+
+  // Negotiate the configuration for the specified dependencies of the
+  // specified dependent. Return true if the configuration has changed.
+  //
+  bool
+  negotiate_configuration (
+    package_configurations&,
+    package_skeleton& dependent,
+    pair<size_t, size_t> position,
+    const small_vector<reference_wrapper<package_skeleton>, 1>& dependencies);
+}
+
+#endif // BPKG_PACKAGE_CONFIGURATION_HXX
diff --git a/bpkg/package-skeleton.cxx b/bpkg/package-skeleton.cxx
index e0d85ed..8b4b09f 100644
--- a/bpkg/package-skeleton.cxx
+++ b/bpkg/package-skeleton.cxx
@@ -20,6 +20,8 @@
 #include <libbuild2/lexer.hxx>
 #include <libbuild2/parser.hxx>
 
+#include <libbuild2/config/utility.hxx>
+
 #include <bpkg/package.hxx>
 #include <bpkg/database.hxx>
 #include <bpkg/manifest-utility.hxx>
@@ -38,6 +40,119 @@ namespace bpkg
 
   void
   build2_init (const common_options&);
+}
+
+namespace bpkg
+{
+  // Check whether the specified configuration variable override has a project
+  // variable (i.e., its name starts with config.<project>). If the last
+  // argument is not NULL, then set it to the length of the variable portion.
+  //
+  // Note that some user-specified variables may have qualifications
+  // (global, scope, etc) but there is no reason to expect any project
+  // configuration variables to use such qualifications (since they can
+  // only apply to one project). So we ignore all qualified variables.
+  //
+  static inline bool
+  project_override (const string& v, const string& p, size_t* l = nullptr)
+  {
+    size_t n (p.size ());
+
+    if (v.compare (0, n, p) == 0)
+    {
+      if (v[n] == '.')
+      {
+        if (l != nullptr)
+          *l = v.find_first_of ("=+ \t", n + 1);
+
+        return true;
+      }
+      else if (strchr ("=+ \t", v[n]) != nullptr)
+      {
+        if (l != nullptr)
+          *l = n;
+
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  // Check whether the specified configuration variable name is a project
+  // variable (i.e., its name starts with config.<project>).
+  //
+  static inline bool
+  project_variable (const string& v, const string& p)
+  {
+    size_t n (p.size ());
+    return v.compare (0, n, p) == 0 && (v[n] == '.' || v[n] == '\0');
+  }
+
+  // Customized buildfile parser that is used to detect and diagnose
+  // references to undefined dependency configuration variables.
+  //
+  class buildfile_parser: public build2::parser
+  {
+  public:
+    buildfile_parser (build2::context& ctx,
+                      const strings& dvps,
+                      optional<size_t> dvps_pending = {})
+        : parser (ctx),
+          dependency_var_prefixes_ (dvps),
+          dependency_var_prefixes_pending_ (dvps_pending) {}
+
+  protected:
+    virtual build2::lookup
+    lookup_variable (build2::name&& qual,
+                     string&& name,
+                     const build2::location& loc) override
+    {
+      using namespace build2;
+      using build2::fail;
+      using build2::info;
+
+      // To avoid making copies of the name, pre-check if it is from one
+      // of the dependencies.
+      //
+      optional<string> dep;
+      if (!pre_parse_ && qual.empty ())
+      {
+        auto b (dependency_var_prefixes_.begin ());
+        auto e (dependency_var_prefixes_pending_
+                ? b + *dependency_var_prefixes_pending_
+                : dependency_var_prefixes_.end ());
+
+        if (find_if (b, e,
+                     [&name] (const string& p)
+                     {
+                       return project_variable (name, p);
+                     }) != e)
+          dep = name;
+      }
+
+      lookup l (parser::lookup_variable (move (qual), move (name), loc));
+
+      if (dep && !l.defined ())
+        fail (loc) << "undefined dependency configuration variable " << *dep <<
+          info << "was " << *dep << " set in earlier prefer or require clause?";
+
+      return l;
+    }
+
+  private:
+    const strings& dependency_var_prefixes_;
+    optional<size_t> dependency_var_prefixes_pending_;
+  };
+
+  static void
+  create_context (package_skeleton&, const strings&);
+
+  // Note: cannot be package_skeleton member function due to iterator return
+  // (build2 stuff is only forward-declared in the header).
+  //
+  static build2::scope_map::iterator
+  bootstrap (package_skeleton&, const strings&);
 
   package_skeleton::
   ~package_skeleton ()
@@ -46,8 +161,36 @@ namespace bpkg
 
   package_skeleton::
   package_skeleton (package_skeleton&& v)
+      : package (move (v.package)),
+        system (v.system),
+        available (move (v.available)),
+        co_ (v.co_),
+        db_ (v.db_),
+        var_prefix_ (move (v.var_prefix_)),
+        config_vars_ (move (v.config_vars_)),
+        disfigure_ (v.disfigure_),
+        config_srcs_ (v.config_srcs_),
+        src_root_ (move (v.src_root_)),
+        out_root_ (move (v.out_root_)),
+        created_ (v.created_),
+        verified_ (v.verified_),
+        loaded_old_config_ (v.loaded_old_config_),
+        develop_ (v.develop_),
+        ctx_ (move (v.ctx_)),
+        rs_ (v.rs_),
+        cmd_vars_ (move (v.cmd_vars_)),
+        cmd_vars_cache_ (v.cmd_vars_cache_),
+        dependent_vars_ (move (v.dependent_vars_)),
+        dependent_orgs_ (move (v.dependent_orgs_)),
+        reflect_ (move (v.reflect_)),
+        dependency_reflect_ (move (v.dependency_reflect_)),
+        dependency_reflect_index_ (v.dependency_reflect_index_),
+        dependency_reflect_pending_ (v.dependency_reflect_pending_),
+        dependency_var_prefixes_ (move (v.dependency_var_prefixes_)),
+        dependency_var_prefixes_pending_ (v.dependency_var_prefixes_pending_),
+        prefer_accept_ (v.prefer_accept_)
   {
-    *this = move (v);
+    v.db_ = nullptr;
   }
 
   package_skeleton& package_skeleton::
@@ -55,22 +198,36 @@ namespace bpkg
   {
     if (this != &v)
     {
+      package = move (v.package);
+      system = v.system;
+      available = move (v.available);
       co_ = v.co_;
       db_ = v.db_;
-      available_ = v.available_;
+      var_prefix_ = move (v.var_prefix_);
       config_vars_ = move (v.config_vars_);
+      disfigure_ = v.disfigure_;
+      config_srcs_ = v.config_srcs_;
       src_root_ = move (v.src_root_);
       out_root_ = move (v.out_root_);
       created_ = v.created_;
+      verified_ = v.verified_;
+      loaded_old_config_ = v.loaded_old_config_;
+      develop_ = v.develop_;
       ctx_ = move (v.ctx_);
       rs_ = v.rs_;
       cmd_vars_ = move (v.cmd_vars_);
-      reflect_names_ = move (v.reflect_names_);
-      reflect_vars_ = move (v.reflect_vars_);
-      reflect_frag_ = move (v.reflect_frag_);
+      cmd_vars_cache_ = v.cmd_vars_cache_;
+      dependent_vars_ = move (v.dependent_vars_);
+      dependent_orgs_ = move (v.dependent_orgs_);
+      reflect_ = move (v.reflect_);
+      dependency_reflect_ = move (v.dependency_reflect_);
+      dependency_reflect_index_ = v.dependency_reflect_index_;
+      dependency_reflect_pending_ = v.dependency_reflect_pending_;
+      dependency_var_prefixes_ = move (v.dependency_var_prefixes_);
+      dependency_var_prefixes_pending_ = v.dependency_var_prefixes_pending_;
+      prefer_accept_ = v.prefer_accept_;
 
       v.db_ = nullptr;
-      v.available_ = nullptr;
     }
 
     return *this;
@@ -78,34 +235,135 @@ namespace bpkg
 
   package_skeleton::
   package_skeleton (const package_skeleton& v)
-      : co_ (v.co_),
+      : package (v.package),
+        system (v.system),
+        available (v.available),
+        co_ (v.co_),
         db_ (v.db_),
-        available_ (v.available_),
+        var_prefix_ (v.var_prefix_),
         config_vars_ (v.config_vars_),
+        disfigure_ (v.disfigure_),
+        config_srcs_ (v.config_srcs_),
         src_root_ (v.src_root_),
         out_root_ (v.out_root_),
         created_ (v.created_),
+        verified_ (v.verified_),
+        loaded_old_config_ (v.loaded_old_config_),
+        develop_ (v.develop_),
         cmd_vars_ (v.cmd_vars_),
-        reflect_names_ (v.reflect_names_),
-        reflect_vars_ (v.reflect_vars_),
-        reflect_frag_ (v.reflect_frag_)
+        cmd_vars_cache_ (v.cmd_vars_cache_),
+        dependent_vars_ (v.dependent_vars_),
+        dependent_orgs_ (v.dependent_orgs_),
+        reflect_ (v.reflect_),
+        dependency_reflect_ (v.dependency_reflect_),
+        dependency_reflect_index_ (v.dependency_reflect_index_),
+        dependency_reflect_pending_ (v.dependency_reflect_pending_),
+        dependency_var_prefixes_ (v.dependency_var_prefixes_),
+        dependency_var_prefixes_pending_ (v.dependency_var_prefixes_pending_),
+        prefer_accept_ (v.prefer_accept_)
   {
     // The idea here is to create an "unloaded" copy but with enough state
     // that it can be loaded if necessary.
+    //
+    // Note that there is a bit of a hole in this logic with regards to the
+    // prefer_accept_ semantics but it looks like we cannot plausible trigger
+    // it (which is fortified with an assert in evaluate_reflect(); note that
+    // doing it here would be overly strict since this may have a left-over
+    // prefer_accept_ position).
+  }
+
+  void package_skeleton::
+  reset ()
+  {
+    assert (db_ != nullptr); // Cannot be called after collect_config().
+
+    rs_ = nullptr;
+    ctx_ = nullptr; // Free.
+
+    cmd_vars_.clear ();
+    cmd_vars_cache_ = false;
+
+    dependent_vars_.clear ();
+    dependent_orgs_.clear ();
+
+    reflect_.clear ();
+
+    dependency_reflect_.clear ();
+    dependency_reflect_index_ = 0;
+    dependency_reflect_pending_ = 0;
+
+    dependency_var_prefixes_.clear ();
+    dependency_var_prefixes_pending_ = 0;
+
+    prefer_accept_ = nullopt;
   }
 
   package_skeleton::
   package_skeleton (const common_options& co,
-                    database& db,
-                    const available_package& ap,
+                    package_key pk,
+                    bool sys,
+                    shared_ptr<const available_package> ap,
                     strings cvs,
+                    bool df,
+                    const vector<config_variable>* css,
                     optional<dir_path> src_root,
                     optional<dir_path> out_root)
-      : co_ (&co), db_ (&db), available_ (&ap), config_vars_ (move (cvs))
+      : package (move (pk)),
+        system (sys),
+        available (move (ap)),
+        co_ (&co),
+        db_ (&package.db.get ()),
+        var_prefix_ ("config." + package.name.variable ()),
+        config_vars_ (move (cvs)),
+        disfigure_ (df),
+        config_srcs_ (df ? nullptr : css)
   {
-    // Should not be created for stubs.
+    if (available != nullptr)
+      assert (available->bootstrap_build); // Should have skeleton info.
+    else
+      assert (system);
+
+    // We are only interested in old user configuration variables.
+    //
+    if (config_srcs_ != nullptr)
+    {
+      if (find_if (config_srcs_->begin (), config_srcs_->end (),
+                   [] (const config_variable& v)
+                   {
+                     return v.source == config_source::user;
+                   }) == config_srcs_->end ())
+        config_srcs_ = nullptr;
+    }
+
+    // We don't need to load old user configuration if there isn't any and
+    // there is no new project configuration specified by the user.
+    //
+    // Note that at first it may seem like we shouldn't do this for any system
+    // packages but if we want to verify the user configuration, why not do so
+    // for system if we can (i.e., have skeleton info)?
     //
-    assert (available_->bootstrap_build);
+    if (available == nullptr)
+      loaded_old_config_ = true;
+    else
+      loaded_old_config_ =
+        (config_srcs_ == nullptr) &&
+        find_if (config_vars_.begin (), config_vars_.end (),
+                 [this] (const string& v)
+                 {
+                   // For now tighten it even further so that we can continue
+                   // using repositories without package skeleton information
+                   // (bootstrap.build, root.build). See load_old_config() for
+                   // details.
+                   //
+#if 0
+                   return project_override (v, var_prefix_);
+#else
+                   size_t vn;
+                   size_t pn (var_prefix_.size ());
+                   return (project_override (v, var_prefix_, &vn) &&
+                           v.compare (pn, vn - pn, ".develop") == 0);
+#endif
+                 }) == config_vars_.end ();
 
     if (src_root)
     {
@@ -118,6 +376,380 @@ namespace bpkg
       assert (!out_root);
   }
 
+  // Serialize a variable assignment for a command line override.
+  //
+  static string
+  serialize_cmdline (const string& var, const build2::value& val,
+                     build2::names& storage)
+  {
+    using namespace build2;
+
+    string r (var + '=');
+
+    if (val.null)
+      r += "[null]";
+    else
+    {
+      storage.clear ();
+      names_view nv (reverse (val, storage));
+
+      if (!nv.empty ())
+      {
+        // Note: we need to use command-line (effective) quoting.
+        //
+        ostringstream os;
+        to_stream (os, nv, quote_mode::effective, '@');
+        r += os.str ();
+      }
+    }
+
+    return r;
+  }
+
+  // Reverse value to names.
+  //
+  static optional<build2::names>
+  reverse_value (const build2::value& val)
+  {
+    using namespace build2;
+
+    if (val.null)
+      return nullopt;
+
+    names storage;
+    names_view nv (reverse (val, storage));
+
+    return (nv.data () == storage.data ()
+            ? move (storage)
+            : names (nv.begin (), nv.end ()));
+  }
+
+  // Return the dependent (origin==buildfile) configuration variables as
+  // command line overrides. If the second argument is not NULL, then populate
+  // it with the corresponding originating dependents.
+  //
+  static strings
+  dependent_cmd_vars (const package_configuration& cfg,
+                      vector<package_key>* orgs = nullptr)
+  {
+    using build2::config::variable_origin;
+
+    strings r;
+
+    for (const config_variable_value& v: cfg)
+    {
+      if (v.origin == variable_origin::buildfile)
+      {
+        r.push_back (v.serialize_cmdline ());
+
+        if (orgs != nullptr)
+          orgs->push_back (*v.dependent);
+      }
+    }
+
+    return r;
+  }
+
+  void package_skeleton::
+  reload_defaults (package_configuration& cfg)
+  {
+    // Should only be called before dependent_config()/evaluate_*().
+    //
+    assert (dependent_vars_.empty ()     &&
+            reflect_.empty ()            &&
+            dependency_reflect_.empty () &&
+            available != nullptr         &&
+            ctx_ == nullptr);
+
+    if (!loaded_old_config_)
+      load_old_config ();
+
+    try
+    {
+      using namespace build2;
+
+      // This is what needs to happen to the variables of different origins in
+      // the passed configuration:
+      //
+      // default              -- reloaded
+      // buildfile/dependent  -- made command line override
+      // override/user        -- should match what's in config_vars_
+      // undefined            -- reloaded
+      //
+      // Note also that on the first call we will have no configuration. And
+      // so to keep things simple, we merge variable of the buildfile origin
+      // into cmd_vars and then rebuild things from scratch. Note, however,
+      // that below we need to sort out these merged overrides into user and
+      // dependent, so we keep the old configuration for reference.
+      //
+      // Note also that dependent values do not clash with user overrides by
+      // construction (in evaluate_{prefer_accept,require}()): we do not add
+      // as dependent variables that have the override origin.
+      //
+      scope& rs (
+        *bootstrap (
+          *this, merge_cmd_vars (dependent_cmd_vars (cfg)))->second.front ());
+
+      // Load project's root.build.
+      //
+      load_root (rs);
+
+      package_configuration old (move (cfg));
+      cfg.package = move (old.package);
+
+      // Note that a configuration variable may not have a default value so we
+      // cannot just iterate over all the config.<name>** values set on the
+      // root scope. Our options seem to be either iterating over the variable
+      // pool or forcing the config module with config.config.module=true and
+      // then using its saved variables map. Since the amount of stuff we load
+      // is quite limited, there shouldn't be too many variables in the pool.
+      // So let's go with the simpler approach for now.
+      //
+      // Though the saved variables map approach would have been more accurate
+      // since that's the variables that were introduced with the config
+      // directive. Potentially the user could just have a buildfile
+      // config.<name>** variable but it feels like that should be harmless
+      // (we will return it but nobody will presumably use that information).
+      // Also, if/when we start tracking the configuration variable
+      // dependencies (i.e., which default value depend on which config
+      // variable), then the saved variables map seem like the natural place
+      // to keep this information.
+      //
+      for (const variable& var: rs.ctx.var_pool)
+      {
+        if (!project_variable (var.name, var_prefix_))
+          continue;
+
+        using config::variable_origin;
+
+        pair<variable_origin, lookup> ol (config::origin (rs, var));
+
+        switch (ol.first)
+        {
+        case variable_origin::default_:
+        case variable_origin::override_:
+        case variable_origin::undefined:
+          {
+            config_variable_value v {var.name, ol.first, {}, {}, {}, false};
+
+            // Override could mean user override from config_vars_ or the
+            // dependent override that we have merged above.
+            //
+            if (v.origin == variable_origin::override_)
+            {
+              if (config_variable_value* ov = old.find (v.name))
+              {
+                if (ov->origin == variable_origin::buildfile)
+                {
+                  v.origin = variable_origin::buildfile;
+                  v.dependent = move (ov->dependent);
+                  v.confirmed = ov->confirmed;
+                }
+                else
+                  assert (ov->origin == variable_origin::override_);
+              }
+            }
+
+            // Save value.
+            //
+            if (v.origin != variable_origin::undefined)
+              v.value = reverse_value (*ol.second);
+
+            // Save type.
+            //
+            if (var.type != nullptr)
+              v.type = var.type->name;
+
+            cfg.push_back (move (v));
+            break;
+          }
+        case variable_origin::buildfile:
+          {
+            // Feel like this shouldn't happen since we have disfigured them.
+            //
+            assert (false);
+            break;
+          }
+        }
+      }
+
+      verified_ = true; // Managed to load without errors.
+      ctx_ = nullptr;
+    }
+    catch (const build2::failed&)
+    {
+      throw failed (); // Assume the diagnostics has already been issued.
+    }
+  }
+
+  void package_skeleton::
+  load_overrides (package_configuration& cfg)
+  {
+    // Should only be called before dependent_config()/evaluate_*() and only
+    // on system package without skeleton info.
+    //
+    assert (dependent_vars_.empty ()     &&
+            reflect_.empty ()            &&
+            dependency_reflect_.empty () &&
+            available == nullptr         &&
+            system);
+
+    if (find_if (config_vars_.begin (), config_vars_.end (),
+                 [this] (const string& v)
+                 {
+                   return project_override (v, var_prefix_);
+                 }) == config_vars_.end ())
+      return;
+
+    try
+    {
+      using namespace build2;
+      using build2::fail;
+      using build2::endf;
+
+      using config::variable_origin;
+
+      // Create the build context.
+      //
+      create_context (*this, strings {});
+      context& ctx (*ctx_);
+
+      scope& gs (ctx.global_scope.rw ());
+      auto& vp (ctx.var_pool.rw ());
+
+      for (const string& v: config_vars_)
+      {
+        size_t vn;
+        if (!project_override (v, var_prefix_, &vn))
+          continue;
+
+        const variable& var (vp.insert (string (v, 0, vn)));
+
+        // Parse the value part (note that all evaluate_require() cares about
+        // is whether the value is true or not, but we do need accurate values
+        // for diagnostics).
+        //
+        size_t p (v.find ('=', vn));
+        assert (p != string::npos);
+        if (v[p + 1] == '+')
+          ++p;
+
+        optional<names> val;
+        {
+          // Similar to context() ctor.
+          //
+          istringstream is (string (v, p + 1));
+          is.exceptions (istringstream::failbit | istringstream::badbit);
+
+          path_name in ("<cmdline>");
+          lexer lex (is, in, 1 /* line */, "\'\"\\$("); // Effective.
+
+          parser par (ctx);
+          pair<value, token> r (
+            par.parse_variable_value (lex, gs, &build2::work, var));
+
+          if (r.second.type != token_type::eos)
+            fail << "invalid command line variable override '" << v << "'";
+
+          val = reverse_value (r.first);
+        }
+
+        // @@ Should we do anything with append/prepend?
+        //
+        if (config_variable_value* v = cfg.find (var.name))
+          v->value = move (val);
+        else
+          cfg.push_back (
+            config_variable_value {
+              var.name, variable_origin::override_, {}, move (val), {}, false});
+      }
+
+      ctx_ = nullptr; // Free.
+    }
+    catch (const build2::failed&)
+    {
+      throw failed (); // Assume the diagnostics has already been issued.
+    }
+  }
+
+  pair<bool, string> package_skeleton::
+  verify_sensible (const package_configuration& cfg)
+  {
+    // Should only be called before dependent_config()/evaluate_*().
+    //
+    assert (dependent_vars_.empty ()     &&
+            reflect_.empty ()            &&
+            dependency_reflect_.empty () &&
+            available != nullptr         &&
+            ctx_ == nullptr);
+
+    if (!loaded_old_config_)
+      load_old_config ();
+
+    try
+    {
+      using namespace build2;
+
+      // For now we treat any failure to load root.build as bad configuration,
+      // which is not very precise. One idea to make this more precise would
+      // be to invent some kind of tagging for "bad configuration" diagnostics
+      // (e.g., either via an attribute or via special config.assert directive
+      // or some such).
+      //
+      // For now we rely on load_defaults() and load_old_config() to "flush"
+      // out any unrelated errors (e.g., one of the modules configuration is
+      // bad, etc). However, if that did not happen naturally, then we must do
+      // it ourselves.
+      //
+      if (!verified_)
+      {
+        scope& rs (
+          *bootstrap (*this, merge_cmd_vars (strings {}))->second.front ());
+        load_root (rs);
+
+        verified_ = true;
+        ctx_ = nullptr;
+      }
+
+      scope& rs (
+        *bootstrap (
+          *this, merge_cmd_vars (dependent_cmd_vars (cfg)))->second.front ());
+
+      // Load project's root.build while redirecting the diagnostics stream.
+      //
+      ostringstream ds;
+      auto dg (make_guard ([ods = diag_stream] () {diag_stream = ods;}));
+      diag_stream = &ds;
+
+      pair<bool, string> r;
+      try
+      {
+        load_root (rs);
+        r.first = true;
+      }
+      catch (const build2::failed&)
+      {
+        r.first = false;
+        r.second = trim (ds.str ());
+      }
+
+      ctx_ = nullptr;
+      return r;
+    }
+    catch (const build2::failed&)
+    {
+      throw failed (); // Assume the diagnostics has already been issued.
+    }
+  }
+
+  void package_skeleton::
+  dependent_config (const package_configuration& cfg)
+  {
+    assert (dependent_vars_.empty ()); // Must be called at most once.
+
+    dependent_vars_ = dependent_cmd_vars (cfg, &dependent_orgs_);
+  }
+
   // Print the location of a depends value in the specified manifest file.
   //
   // Note that currently we only use this function for the external packages.
@@ -126,7 +758,7 @@ namespace bpkg
   // the temp directory is not cleaned in case of an error. Maybe one day.
   //
   static void
-  depends_location (const diag_record& dr,
+  depends_location (const build2::diag_record& dr,
                     const path& mf,
                     size_t depends_index)
   {
@@ -146,10 +778,10 @@ namespace bpkg
         {
           if (nv.name == "depends" && i++ == depends_index)
           {
-            dr << info (location (p.name (),
-                                  nv.value_line,
-                                  nv.value_column))
-               << "depends value defined here";
+            dr << build2::info (build2::location (mf,
+                                                  nv.value_line,
+                                                  nv.value_column))
+               << "in depends manifest value defined here";
             break;
           }
         }
@@ -160,16 +792,29 @@ namespace bpkg
   }
 
   bool package_skeleton::
-  evaluate_enable (const string& cond, size_t depends_index)
+  evaluate_enable (const string& cond, pair<size_t, size_t> indexes)
   {
+    size_t depends_index (indexes.first);
+
     try
     {
       using namespace build2;
       using build2::fail;
+      using build2::info;
       using build2::endf;
 
+      // Drop the state from the previous evaluation of prefer/accept.
+      //
+      if (prefer_accept_)
+      {
+        ctx_ = nullptr;
+        prefer_accept_ = nullopt;
+      }
+
       scope& rs (load ());
 
+      // Evaluate the enable condition.
+      //
       istringstream is ('(' + cond + ')');
       is.exceptions (istringstream::failbit | istringstream::badbit);
 
@@ -183,21 +828,24 @@ namespace bpkg
       uint64_t il (1);
 
       auto df = build2::make_diag_frame (
-        [&cond, &rs, depends_index] (const diag_record& dr)
+        [this, &cond, &rs, depends_index] (const build2::diag_record& dr)
         {
           dr << info << "enable condition: (" << cond << ")";
 
           // For external packages we have the manifest so print the location
           // of the depends value in questions.
           //
-          if (!rs.out_eq_src ())
+          if (rs.out_eq_src ())
+            dr << info << "in depends manifest value of package "
+               << package.name;
+          else
             depends_location (dr,
                               rs.src_path () / manifest_file,
                               depends_index);
         });
 
       lexer l (is, in, il /* start line */);
-      parser p (rs.ctx);
+      buildfile_parser p (rs.ctx, dependency_var_prefixes_);
       value v (p.parse_eval (l, rs, rs, parser::pattern_mode::expand));
 
       try
@@ -217,9 +865,13 @@ namespace bpkg
     }
   }
 
+#if 1
+
   void package_skeleton::
-  evaluate_reflect (const string& refl, size_t depends_index)
+  evaluate_reflect (const string& refl, pair<size_t, size_t> indexes)
   {
+    size_t depends_index (indexes.first);
+
     // The reflect configuration variables are essentially overrides that will
     // be passed on the command line when we configure the package. They could
     // clash with configuration variables specified by the user (config_vars_)
@@ -227,6 +879,11 @@ namespace bpkg
     // also argue we should diagnose this case and fail not to cause more
     // confusion.
     //
+    // They could also clash with dependent configuration. Probably should be
+    // handled in the same way (it's just another type of "user"). Yes, since
+    // dependent_vars_ are entered as cmd line overrides, this is how they are
+    // treated.
+    //
     // It seems like the most straightforward way to achieve the desired
     // semantics with the mechanisms that we have (in other words, without
     // inventing another "level" of overrides) is to evaluate the reflect
@@ -234,19 +891,327 @@ namespace bpkg
     // variables set by root.build in conditions, (2) override default values
     // of configuration variables (and those loaded from config.build), and
     // (3) be overriden by configuration variables specified by the user.
-    // Naturally, this approach is not without a few corner cases:
+    // Naturally, this approach is probably not without a few corner cases.
+    //
+    // We may also have configuration values from the previous reflect clause
+    // which we want to "factor in" before evaluating the next clause (enable,
+    // reflect etc.; so that they can use the previously reflected values or
+    // values that are derived from them in root.build). It seems like we have
+    // two options here: either enter them as true overrides similar to
+    // config_vars_ or just evaluate them similar to loading config.build
+    // (which, BTW, we might have, in case of an external package). The big
+    // problem with the former approach is that it will then prevent any
+    // further reflect clauses from modifying the same values.
+    //
+    // So overall it feels like we have iterative/compartmentalized
+    // configuration process. A feedback loop, in a sense. And it's the
+    // responsibility of the package author (who is in control of both
+    // root.build and manifest) to arrange for suitable compartmentalization.
     //
-    // 1. Append in the reflect clause may not produce the desired result
-    //    (i.e., it will append to the default value in root.build) rather
-    //    than overriding it, as would have happen if it were a real variable
-    //    override.
+    try
+    {
+      // Note: similar in many respects to evaluate_enable().
+      //
+      using namespace build2;
+      using config::variable_origin;
+      using build2::diag_record;
+      using build2::fail;
+      using build2::info;
+      using build2::endf;
+
+      // Drop the state from the previous evaluation of prefer/accept if it's
+      // from the wrong position.
+      //
+      optional<size_t> dependency_var_prefixes_pending;
+      if (prefer_accept_)
+      {
+        if (*prefer_accept_ != indexes)
+        {
+          ctx_ = nullptr;
+          prefer_accept_ = nullopt;
+        }
+        else
+        {
+          // This could theoretically happen if we make a copy of the skeleton
+          // after evaluate_prefer_accept() and then attempt to continue with
+          // the call on the copy to evaluate_reflect() passing the same
+          // position. But it doesn't appear our usage should trigger this.
+          //
+          assert (ctx_ != nullptr);
+
+          dependency_var_prefixes_pending = dependency_var_prefixes_pending_;
+        }
+      }
+
+      scope& rs (load ());
+
+      // Collect all the set config.<name>.* variables on the first pass and
+      // filter out unchanged on the second.
+      //
+      // Note: a lot of this code is inspired by the config module.
+      //
+      struct rvar
+      {
+        const variable* var;
+        const value*    val;
+        size_t          ver;
+      };
+
+      class rvars: public vector<rvar>
+      {
+      public:
+        pair<iterator, bool>
+        insert (const rvar& v)
+        {
+          auto i (find_if (begin (), end (),
+                           [&v] (const rvar& o) {return v.var == o.var;}));
+          if (i != end ())
+            return make_pair (i, false);
+
+          push_back (v);
+          return make_pair (--end (), true);
+        }
+      };
+
+      rvars vars;
+
+      auto process = [this, &rs, &vars] (bool collect)
+      {
+        // @@ TODO: would be nice to verify no bogus variables are set (can
+        //    probably only be done via the saved variables map).
+
+        for (auto p (rs.vars.lookup_namespace (var_prefix_));
+             p.first != p.second;
+             ++p.first)
+        {
+          const variable& var (p.first->first);
+
+          // This can be one of the overrides (__override, __prefix, etc),
+          // which we skip.
+          //
+          if (var.override ())
+            continue;
+
+          // What happens to version if overriden? A: appears to be still
+          // incremented!
+          //
+          const variable_map::value_data& val (p.first->second);
+
+          if (collect)
+            vars.insert (rvar {&var, nullptr, val.version});
+          else
+          {
+            auto p (vars.insert (rvar {&var, &val, 0}));
+
+            if (!p.second)
+            {
+              auto i (p.first);
+
+              if (i->ver == val.version)
+                vars.erase (i); // Unchanged.
+              else
+                i->val = &val;
+            }
+          }
+        }
+      };
+
+      // Evaluate the reflect clause.
+      //
+      istringstream is (refl);
+      is.exceptions (istringstream::failbit | istringstream::badbit);
+
+      path_name in ("<depends-reflect-clause>");
+      uint64_t il (1);
+
+      // Note: keep it active until the end (see the override detection).
+      //
+      auto df = build2::make_diag_frame (
+        [this, &refl, &rs, depends_index] (const build2::diag_record& dr)
+        {
+          // Probably safe to assume a one-line fragment contains a variable
+          // assignment.
+          //
+          if (refl.find ('\n') == string::npos)
+            dr << info << "reflect variable: " << trim (string (refl));
+          else
+            dr << info << "reflect clause:\n"
+               << trim_right (string (refl));
+
+          // For external packages we have the manifest so print the
+          // location of the depends value in questions.
+          //
+          if (rs.out_eq_src ())
+            dr << info << "in depends manifest value of package "
+               << package.name;
+          else
+            depends_location (dr,
+                              rs.src_path () / manifest_file,
+                              depends_index);
+        });
+
+      lexer l (is, in, il /* start line */);
+      buildfile_parser p (rs.ctx,
+                          dependency_var_prefixes_,
+                          dependency_var_prefixes_pending);
+
+      process (true);
+      p.parse_buildfile (l, &rs, rs);
+      process (false);
+
+      // Add to the vars set the reflect variables collected previously.
+      //
+      auto& vp (rs.var_pool ());
+      for (const reflect_variable_value& v: reflect_)
+      {
+        const variable* var (vp.find (v.name));
+        assert (var != nullptr); // Must be there (set by load()).
+
+        auto p (vars.insert (rvar {var, nullptr, 0}));
+
+        if (p.second)
+          p.first->val = rs.vars[*var].value; // Must be there (set by load()).
+      }
+
+      // Re-populate everything from the var set but try to re-use buffers as
+      // much a possible (normally we would just be appending more variables
+      // at the end).
+      //
+      reflect_.resize (vars.size ());
+
+      // Collect the config.<name>.* variables that were changed by this
+      // and previous reflect clauses.
+      //
+      for (size_t i (0); i != vars.size (); ++i)
+      {
+        const variable& var (*vars[i].var);
+        const value& val (*vars[i].val);
+
+        pair<variable_origin, lookup> ol (
+          config::origin (rs,
+                          var,
+                          pair<lookup, size_t> {
+                            lookup {val, var, rs.vars}, 1 /* depth */}));
+
+        reflect_variable_value& v (reflect_[i]);
+        v.name = var.name;
+        v.origin = ol.first;
+
+        if (ol.first == variable_origin::override_)
+        {
+          // Detect an overridden reflect value, but allowing it if the values
+          // match (think both user/dependent and reflect trying to enable the
+          // same feature).
+          //
+          // What would be the plausible scenarios for an override?
+          //
+          // 1. Append override that adds some backend or some such to the
+          //    reflect value.
+          //
+          // 2. A reflect may enable a feature based on the dependency
+          //    alternative selected (e.g., I see we are using Qt6 so we might
+          //    as well enable feature X). The user may want do disable it
+          //    with an override.
+          //
+          // Note also that a sufficiently smart reflect clause can detect if
+          // a variable is overridden (with $config.origin()) and avoid the
+          // clash. Perhaps that should be the recommendation for reflect
+          // variables that can also plausibly be set by the user (it feels
+          // like configuration variables have the intf/impl split similar
+          // to libraries)?
+          //
+          if (val != *ol.second)
+          {
+            // See if this is a dependent or user override.
+            //
+            const package_key* d (nullptr);
+            {
+              for (size_t i (0); i != dependent_vars_.size (); ++i)
+              {
+                const string& v (dependent_vars_[i]);
+                size_t n (var.name.size ());
+                if (v.compare (0, n, var.name) == 0 && v[n] == '=')
+                {
+                  d = &dependent_orgs_[i];
+                  break;
+                }
+              }
+            }
+
+            diag_record dr (fail);
+
+            dr << "reflect variable " << var << " overriden by ";
+
+            if (d != nullptr)
+              dr << "dependent " << *d;
+            else
+              dr << "user configuration";
+
+            names storage;
+            dr << info << "reflect value: "
+               << serialize_cmdline (var.name, val, storage);
+
+            dr << info << (d != nullptr ? "dependent" : "user") << " value: "
+               << serialize_cmdline (var.name, *ol.second, storage);
+          }
+
+          // Skipped in load(), collect_config(), but used in print_config().
+        }
+        else
+        {
+          assert (ol.first == variable_origin::buildfile);
+
+          // Note that we keep it always untyped letting the config directives
+          // in root.build to take care of typing.
+          //
+          v.value = reverse_value (val);
+        }
+      }
+
+      // Drop the build system state since it needs reloading (some computed
+      // values in root.build may depend on the new configuration values).
+      //
+      ctx_ = nullptr;
+    }
+    catch (const build2::failed&)
+    {
+      throw failed (); // Assume the diagnostics has already been issued.
+    }
+  }
+
+#else
+
+  // @@ TMP: keep this in dep-config-neg but drop in master.
+
+  void package_skeleton::
+  evaluate_reflect (const string& refl, pair<size_t, size_t> indexes)
+  {
+    size_t depends_index (indexes.first);
+
+    // The reflect configuration variables are essentially overrides that will
+    // be passed on the command line when we configure the package. They could
+    // clash with configuration variables specified by the user (config_vars_)
+    // and it feels like user values should take precedence. Though one could
+    // also argue we should diagnose this case and fail not to cause more
+    // confusion.
     //
-    //    config.hello.x ?= 1 # root.build
-    //    config.hello.x += 2 # reflect clause
+    // They could also clash with dependent configuration. Probably should be
+    // handled in the same way (it's just another type of "user"). Yes, since
+    // dependent_vars_ are entered as cmd line overrides, this is how they are
+    // treated.
+    //
+    // It seems like the most straightforward way to achieve the desired
+    // semantics with the mechanisms that we have (in other words, without
+    // inventing another "level" of overrides) is to evaluate the reflect
+    // fragment after loading root.build. This way it will (1) be able to use
+    // variables set by root.build in conditions, (2) override default values
+    // of configuration variables (and those loaded from config.build), and
+    // (3) be overriden by configuration variables specified by the user.
+    // Naturally, this approach is probably not without a few corner cases.
     //
     // We may also have configuration values from the previous reflect clause
-    // which we want to "factor in" before evaluating the next enable or
-    // reflect clauses (so that they can use the previously reflect values or
+    // which we want to "factor in" before evaluating the next clause (enable,
+    // reflect etc.; so that they can use the previously reflected values or
     // values that are derived from them in root.build). It seems like we have
     // two options here: either enter them as true overrides similar to
     // config_vars_ or just evaluate them similar to loading config.build
@@ -259,18 +1224,39 @@ namespace bpkg
     // responsibility of the package author (who is in control of both
     // root.build and manifest) to arrange for suitable compartmentalization.
     //
-    // BTW, a plan B would be to restrict reflect to just config vars in which
-    // case we could merge them with true overrides. Though how exactly would
-    // we do this merging is unclear.
-    //
     try
     {
       // Note: similar in many respects to evaluate_enable().
       //
       using namespace build2;
       using build2::fail;
+      using build2::info;
       using build2::endf;
 
+      // Drop the state from the previous evaluation of prefer/accept if it's
+      // from the wrong position.
+      //
+      optional<size_t> dependency_var_prefixes_pending;
+      if (prefer_accept_)
+      {
+        if (*prefer_accept_ != indexes)
+        {
+          ctx_ = nullptr;
+          prefer_accept_ = nullopt;
+        }
+        else
+        {
+          // This could theoretically happen if we make a copy of the skeleton
+          // after evaluate_prefer_accept() and then attempt to continue with
+          // the call on the copy to evaluate_reflect() passing the same
+          // position. But it doesn't appear our usage should trigger this.
+          //
+          assert (ctx_ != nullptr);
+
+          dependency_var_prefixes_pending = dependency_var_prefixes_pending_;
+        }
+      }
+
       scope& rs (load ());
 
       istringstream is (refl);
@@ -280,21 +1266,24 @@ namespace bpkg
       uint64_t il (1);
 
       auto df = build2::make_diag_frame (
-        [&refl, &rs, depends_index] (const diag_record& dr)
+        [this, &refl, &rs, depends_index] (const build2::diag_record& dr)
         {
           // Probably safe to assume a one-line fragment contains a variable
           // assignment.
           //
           if (refl.find ('\n') == string::npos)
-            dr << info << "reflect variable: " << refl;
+            dr << info << "reflect variable: " << trim (string (refl));
           else
-            dr << info << "reflect fragment:\n"
-               << refl;
+            dr << info << "reflect clause:\n"
+               << trim_right (string (refl));
 
           // For external packages we have the manifest so print the location
           // of the depends value in questions.
           //
-          if (!rs.out_eq_src ())
+          if (rs.out_eq_src ())
+            dr << info << "in depends manifest value of package "
+               << package.name;
+          else
             depends_location (dr,
                               rs.src_path () / manifest_file,
                               depends_index);
@@ -303,11 +1292,11 @@ namespace bpkg
       // Note: a lot of this code is inspired by the config module.
       //
 
-      // Collect all the config.<name>.* variables on the first pass and
+      // Collect all the set config.<name>.* variables on the first pass and
       // filter out unchanged on the second.
       //
       auto& vp (rs.var_pool ());
-      const variable& ns (vp.insert ("config." + name ().variable ()));
+      const string& ns (var_prefix_);
 
       struct value_data
       {
@@ -315,6 +1304,8 @@ namespace bpkg
         size_t       ver;
       };
 
+      // @@ Maybe redo as small_vector?
+      //
       map<const variable*, value_data> vars;
 
       auto process = [&rs, &ns, &vars] (bool collect)
@@ -323,12 +1314,12 @@ namespace bpkg
              p.first != p.second;
              ++p.first)
         {
-          const variable* var (&p.first->first.get ());
+          const variable& var (p.first->first);
 
           // This can be one of the overrides (__override, __prefix, etc),
           // which we skip.
           //
-          if (var->override ())
+          if (var.override ())
             continue;
 
           // What happens to version if overriden? A: appears to be still
@@ -338,11 +1329,11 @@ namespace bpkg
 
           if (collect)
           {
-            vars.emplace (var, value_data {nullptr, val.version});
+            vars.emplace (&var, value_data {nullptr, val.version});
           }
           else
           {
-            auto i (vars.find (var));
+            auto i (vars.find (&var));
 
             if (i != vars.end ())
             {
@@ -352,7 +1343,7 @@ namespace bpkg
                 i->second.val = &val;
             }
             else
-              vars.emplace (var, value_data {&val, 0});
+              vars.emplace (&var, value_data {&val, 0});
           }
         }
       };
@@ -360,15 +1351,26 @@ namespace bpkg
       process (true);
 
       lexer l (is, in, il /* start line */);
-      parser p (rs.ctx);
+      buildfile_parser p (rs.ctx,
+                          dependency_var_prefixes_,
+                          dependency_var_prefixes_pending);
       p.parse_buildfile (l, &rs, rs);
 
       process (false);
 
-      // Add to the map the reflect variables collected previously.
+      // Add to the map the reflect variables collected previously. Note that
+      // we can re-purpose the override since we re-populate it.
       //
-      for (string& n: reflect_names_)
+      for (string& n: reflect_vars_)
       {
+        // Transform `name=value` to just `name`.
+        //
+        {
+          size_t p (n.find ('='));
+          assert (p != string::npos); // We've serialized it so must be there.
+          n.resize (p);
+        }
+
         auto p (vars.emplace (&vp.insert (move (n)), value_data {nullptr, 0}));
 
         if (p.second)
@@ -382,16 +1384,8 @@ namespace bpkg
 
       // Re-populate everything from the map.
       //
-      reflect_names_.clear ();
-      reflect_frag_.clear ();
-
-#if 0
-      // NOTE: see also collect_config() if enabling this.
-      //
       reflect_vars_.clear ();
-#else
-      reflect_vars_ = config_vars_;
-#endif
+      reflect_frag_.clear ();
 
       // Collect the config.<name>.* variables that were changed by this
       // and previous reflect clauses.
@@ -410,31 +1404,13 @@ namespace bpkg
         const variable& var (*p.first);
         const value& val (*p.second.val);
 
-        reflect_names_.push_back (var.name);
-
         // For the accumulated fragment we always save the original and let
         // the standard overriding take its course.
         //
-        reflect_frag_ += var.name;
-        reflect_frag_ += " = ";
-
-        if (val.null)
-          reflect_frag_ += "[null]";
-        else
-        {
-          storage.clear ();
-          names_view nv (reverse (val, storage));
-
-          if (!nv.empty ())
-          {
-            ostringstream os;
-            to_stream (os, nv, quote_mode::normal, '@');
-            reflect_frag_ += os.str ();
-          }
-        }
-
-        reflect_frag_ += '\n';
+        serialize_buildfile (reflect_frag_, var.name, val, storage);
 
+        // Note: this is currently disabled and is likely very outdated.
+        //
         // For the accumulated overrides we have to merge user config_vars_
         // with reflect values. Essentially, we have three possibilities:
         //
@@ -452,6 +1428,9 @@ namespace bpkg
         //    config.hello.backend = foo  # reflect
         //    config.hello.backend += bar # user
         //
+
+        // @@ Can't we redo it via origin() call like in other places?
+        //
         pair<lookup, size_t> org {lookup {val, var, rs.vars}, 1 /* depth */};
         pair<lookup, size_t> ovr;
 
@@ -459,7 +1438,7 @@ namespace bpkg
           ovr = org; // Case #2.
         else
         {
-          // NOTE: see also above and below if enabling this.
+          // NOTE: see also below if enabling this.
           //
 #if 0
           // Case #3.
@@ -519,41 +1498,656 @@ namespace bpkg
           //
           ovr = rs.lookup_override (var, org);
 #else
+          // @@ TODO: probably also depends, not just user.
+          // @@ TODO: maybe we should allow if the same value (say a bool
+          //          feature set to true but both)?!
+
           fail << "command line override of reflect clause variable " << var
                << endf;
 #endif
         }
 
-        string s (var.name + '=');
+        reflect_vars_.push_back (
+          serialize_cmdline (var.name, *ovr.first, storage));
+      }
 
-        if (val.null)
-          s += "[null]";
-        else
+#if 0
+      // TODO: copy over config_vars_ that are not in the map (case #1).
+#endif
+
+      // Drop the build system state since it needs reloading (some computed
+      // values in root.build may depend on the new configuration values).
+      //
+      ctx_ = nullptr;
+    }
+    catch (const build2::failed&)
+    {
+      throw failed (); // Assume the diagnostics has already been issued.
+    }
+  }
+
+#endif
+
+  bool package_skeleton::
+  evaluate_prefer_accept (const dependency_configurations& cfgs,
+                          const string& prefer,
+                          const string& accept,
+                          pair<size_t, size_t> indexes)
+  {
+    size_t depends_index (indexes.first);
+
+    assert (dependency_reflect_index_ <= depends_index);
+
+    try
+    {
+      using namespace build2;
+      using config::variable_origin;
+      using build2::fail;
+      using build2::info;
+      using build2::endf;
+
+      // Drop the state from the previous evaluation of prefer/accept.
+      //
+      if (prefer_accept_)
+      {
+        ctx_ = nullptr;
+        prefer_accept_ = nullopt;
+      }
+
+      // Drop any dependency reflect values from the previous evaluation of
+      // this clause, if any.
+      //
+      if (dependency_reflect_index_ == depends_index)
+        dependency_reflect_.resize (dependency_reflect_pending_);
+
+      // This is what needs to happen to the variables of different origins in
+      // the passed dependency configurations:
+      //
+      // default              -- set as default (value::extra=1)
+      // buildfile/dependent  -- set as buildfile (value::extra=2)
+      // override/user        -- set as override (so cannot be overriden)
+      // undefined            -- ignored
+      //
+      // Note that we set value::extra to 2 for buildfile/dependent values.
+      // This is done so that we can detect when they were set by this
+      // dependent (even if to the same value). Note that the build2 config
+      // module only treats 1 as the default value marker.
+      //
+      // Additionally, for all origins we need to typify the variables.
+      //
+      // All of this is done by load(), including removing and returning the
+      // dependency variable prefixes (config.<project>) which we later add
+      // to dependency_var_prefixes_.
+      //
+      strings dvps;
+      scope& rs (load (cfgs, &dvps, true /* defaults */));
+
+      // Evaluate the prefer clause.
+      //
+      {
+        istringstream is (prefer);
+        is.exceptions (istringstream::failbit | istringstream::badbit);
+
+        path_name in ("<depends-prefer-clause>");
+        uint64_t il (1);
+
+        auto df = build2::make_diag_frame (
+          [this, &prefer, &rs, depends_index] (const build2::diag_record& dr)
+          {
+            dr << info << "prefer clause:\n"
+               << trim_right (string (prefer));
+
+            // For external packages we have the manifest so print the
+            // location of the depends value in questions.
+            //
+            if (rs.out_eq_src ())
+              dr << info << "in depends manifest value of package "
+                 << package.name;
+            else
+              depends_location (dr,
+                                rs.src_path () / manifest_file,
+                                depends_index);
+          });
+
+        lexer l (is, in, il /* start line */);
+        buildfile_parser p (rs.ctx, dependency_var_prefixes_);
+        p.parse_buildfile (l, &rs, rs);
+
+        // Check if the dependent set any stray configuration variables.
+        //
+        for (size_t i (0); i != cfgs.size (); ++i)
         {
-          storage.clear ();
-          names_view nv (reverse (*ovr.first, storage));
+          package_configuration& cfg (cfgs[i]);
 
-          if (!nv.empty ())
+          const string& ns (dvps[i]); // Parallel.
+          for (auto p (rs.vars.lookup_namespace (ns));
+               p.first != p.second;
+               ++p.first)
           {
-            // Note: we need to use command-line (effective) quoting.
+            const variable& var (p.first->first);
+
+            // This can be one of the overrides (__override, __prefix, etc),
+            // which we skip.
             //
-            ostringstream os;
-            to_stream (os, nv, quote_mode::effective, '@');
-            s += os.str ();
+            if (var.override ())
+              continue;
+
+            if (cfg.find (var.name) == nullptr)
+            {
+              fail << "package " << cfg.package.name << " has no "
+                   << "configuration variable " << var.name <<
+                info << var.name << " set in prefer clause of dependent "
+                   << package.string ();
+            }
           }
         }
+      }
+
+      // Evaluate the accept condition.
+      //
+      bool r;
+      {
+        istringstream is ('(' + accept + ')');
+        is.exceptions (istringstream::failbit | istringstream::badbit);
+
+        path_name in ("<depends-accept-clause>");
+        uint64_t il (1);
+
+        auto df = build2::make_diag_frame (
+          [this, &accept, &rs, depends_index] (const build2::diag_record& dr)
+          {
+            dr << info << "accept condition: (" << accept << ")";
 
-        reflect_vars_.push_back (move (s));
+            // For external packages we have the manifest so print the
+            // location of the depends value in questions.
+            //
+            if (rs.out_eq_src ())
+              dr << info << "in depends manifest value of package "
+                 << package.name;
+            else
+              depends_location (dr,
+                                rs.src_path () / manifest_file,
+                                depends_index);
+          });
+
+        lexer l (is, in, il /* start line */);
+        buildfile_parser p (rs.ctx, dependency_var_prefixes_);
+        value v (p.parse_eval (l, rs, rs, parser::pattern_mode::expand));
+
+        try
+        {
+          // Should evaluate to 'true' or 'false'.
+          //
+          r = build2::convert<bool> (move (v));
+        }
+        catch (const invalid_argument& e)
+        {
+          fail (build2::location (in, il)) << e << endf;
+        }
       }
 
-#if 0
-      // TODO: copy over config_vars_ that are not in the map (case #1).
-#endif
+      // If acceptable, update the configuration with the new values, if any.
+      //
+      // We also save the subset of values that were set by this dependent to
+      // be reflected to further clauses.
+      //
+      if (r)
+      {
+        dependency_reflect_index_ = depends_index;
+        dependency_reflect_pending_ = dependency_reflect_.size ();
 
-      // Drop the build system state since it needs reloading (some computed
-      // values in root.build may depend on the new configuration values).
+        for (size_t i (0); i != cfgs.size (); ++i)
+        {
+          package_configuration& cfg (cfgs[i]);
+
+          const string& ns (dvps[i]);
+          for (auto p (rs.vars.lookup_namespace (ns));
+               p.first != p.second;
+               ++p.first)
+          {
+            const variable& var (p.first->first);
+
+            if (var.override ())
+              continue;
+
+            const value& val (p.first->second);
+
+            pair<variable_origin, lookup> ol (
+              config::origin (rs,
+                              var,
+                              pair<lookup, size_t> {
+                                lookup {val, var, rs.vars}, 1 /* depth */}));
+
+            config_variable_value& v (*cfg.find (var.name));
+
+            // An override cannot become a non-override. And a non-override
+            // cannot become an override. Except that the dependency override
+            // could be specified (only) for the dependent.
+            //
+            if (v.origin == variable_origin::override_)
+            {
+              assert (ol.first == variable_origin::override_);
+            }
+            else if (ol.first == variable_origin::override_ &&
+                     v.origin != variable_origin::override_)
+            {
+              fail << "dependency override " << var.name << " specified for "
+                   << "dependent " << package.string () << " but not dependency" <<
+                info << "did you mean to specify ?" << cfg.package.name
+                   << " +{ " << var.name << "=... }";
+            }
+
+            switch (ol.first)
+            {
+            case variable_origin::buildfile:
+              {
+                optional<names> ns (reverse_value (val));
+
+                // If this value was set, save it as a dependency reflect.
+                //
+                if (val.extra == 0)
+                {
+                  dependency_reflect_.push_back (
+                    reflect_variable_value {v.name, ol.first, v.type, ns});
+                }
+
+                // Possible transitions:
+                //
+                // default/undefine -> buildfile -- override dependency default
+                // buildfile        -> buildfile -- override other dependent
+                //
+                if (v.origin == variable_origin::buildfile)
+                {
+                  // If unchanged, then we keep the old originating dependent
+                  // (even if the value was technically "overwritten" by this
+                  // dependent).
+                  //
+                  if (val.extra == 2 || v.value == ns)
+                    break;
+                }
+                else
+                  v.origin = variable_origin::buildfile;
+
+                v.value = move (ns);
+                v.dependent = package; // We are the originating dependent.
+                v.confirmed = true;
+                break;
+              }
+            case variable_origin::default_:
+              {
+                // A default can only come from a default.
+                //
+                assert (ol.first == v.origin);
+                break;
+              }
+            case variable_origin::override_:
+              {
+                // If the value was set by this dependent then we need to
+                // reflect it even if it was overridden (but as the overridden
+                // value). Note that the mere presence of the value in rs.vars
+                // is not enough to say that it was set -- it could also be
+                // the default value. But we can detect that by examining
+                // value::extra.
+                //
+                if (val.extra == 0)
+                {
+                  dependency_reflect_.push_back (
+                    reflect_variable_value {
+                      v.name, ol.first, v.type, reverse_value (*ol.second)});
+                }
+                break;
+              }
+            case variable_origin::undefined:
+              {
+                // Not possible since we have the defined original.
+                //
+                assert (false);
+                break;
+              }
+            }
+          }
+        }
+
+        // Note that because we add it here, the following reflect clause will
+        // not be able to expand undefined values. We handle this by keeping a
+        // pending position.
+        //
+        dependency_var_prefixes_pending_ = dependency_var_prefixes_.size ();
+        dependency_var_prefixes_.insert (dependency_var_prefixes_.end (),
+                                         make_move_iterator (dvps.begin ()),
+                                         make_move_iterator (dvps.end ()));
+
+        // Note: do not drop the build system state yet since it should be
+        // reused by the following reflect clause, if any.
+        //
+        prefer_accept_ = indexes;
+      }
+      else
+        ctx_ = nullptr;
+
+      return r;
+    }
+    catch (const build2::failed&)
+    {
+      throw failed (); // Assume the diagnostics has already been issued.
+    }
+  }
+
+  bool package_skeleton::
+  evaluate_require (const dependency_configurations& cfgs,
+                    const string& require, pair<size_t, size_t> indexes)
+  {
+    size_t depends_index (indexes.first);
+
+    assert (dependency_reflect_index_ <= depends_index);
+
+    try
+    {
+      using namespace build2;
+      using config::variable_origin;
+      using build2::fail;
+      using build2::info;
+      using build2::endf;
+
+      // Drop the state from the previous evaluation of prefer/accept.
+      //
+      if (prefer_accept_)
+      {
+        ctx_ = nullptr;
+        prefer_accept_ = nullopt;
+      }
+
+      // Drop any dependency reflect values from the previous evaluation of
+      // this clause, if any.
+      //
+      if (dependency_reflect_index_ == depends_index)
+        dependency_reflect_.resize (dependency_reflect_pending_);
+
+      // A require clause can only set bool configuration variables and only
+      // to true and may not have any conditions on other configuration
+      // variables (including their origin). As a result, we don't need to set
+      // the default (or other dependent) values, but will need the type
+      // information as well as overrides. Except that the type information
+      // may not be available for system packages, so we must deal with
+      // that. See negotiate_configuration() for details.
+      //
+      strings dvps;
+      scope& rs (load (cfgs, &dvps, false /* defaults */));
+
+      // Evaluate the require clause.
+      //
+      {
+        istringstream is (require);
+        is.exceptions (istringstream::failbit | istringstream::badbit);
+
+        path_name in ("<depends-require-clause>");
+        uint64_t il (1);
+
+        auto df = build2::make_diag_frame (
+          [this, &require, &rs, depends_index] (const build2::diag_record& dr)
+          {
+            dr << info << "require clause:\n"
+               << trim_right (string (require));
+
+            // For external packages we have the manifest so print the
+            // location of the depends value in questions.
+            //
+            if (rs.out_eq_src ())
+              dr << info << "in depends manifest value of package "
+                 << package.name;
+            else
+              depends_location (dr,
+                                rs.src_path () / manifest_file,
+                                depends_index);
+          });
+
+        lexer l (is, in, il /* start line */);
+        buildfile_parser p (rs.ctx, dependency_var_prefixes_);
+        p.parse_buildfile (l, &rs, rs);
+
+        // Check for stray variables and enforce all the require restrictions
+        // (bool, set to true, etc).
+        //
+        for (size_t i (0); i != cfgs.size (); ++i)
+        {
+          package_configuration& cfg (cfgs[i]);
+
+          const string& ns (dvps[i]); // Parallel.
+          for (auto p (rs.vars.lookup_namespace (ns));
+               p.first != p.second;
+               ++p.first)
+          {
+            // Note that because we didn't set any default (or other
+            // dependent) values, all the values we see are set by this
+            // dependent.
+            //
+            const variable& var (p.first->first);
+
+            // This can be one of the overrides (__override, __prefix, etc),
+            // which we skip.
+            //
+            if (var.override ())
+              continue;
+
+            const value& val (p.first->second);
+
+            // Deal with a system package that has no type information.
+            //
+            if (!cfg.system)
+            {
+              const config_variable_value* v (cfg.find (var.name));
+
+              if (v == nullptr)
+              {
+                fail << "package " << cfg.package.name << " has no "
+                     << "configuration variable " << var.name <<
+                  info << var.name << " set in require clause of dependent "
+                     << package.string ();
+              }
+
+              if (!v->type || *v->type != "bool")
+              {
+                fail << "configuration variable " << var.name << " is not of "
+                     << "bool type" <<
+                  info << var.name << " set in require clause of dependent "
+                     << package.string ();
+              }
+            }
+
+            bool r;
+            if (cfg.system)
+            {
+              try
+              {
+                r = build2::convert<bool> (val);
+              }
+              catch (const invalid_argument&)
+              {
+                r = false;
+              }
+            }
+            else
+              r = cast_false<bool> (val);
+
+            if (!r)
+            {
+              fail << "configuration variable " << var.name << " is not set "
+                   << "to true" <<
+                info << var.name << " set in require clause of dependent "
+                   << package.string ();
+            }
+          }
+        }
+      }
+
+      // First determine if acceptable.
+      //
+      bool r (true);
+      for (size_t i (0); i != cfgs.size (); ++i)
+      {
+        package_configuration& cfg (cfgs[i]);
+
+        const string& ns (dvps[i]);
+        for (auto p (rs.vars.lookup_namespace (ns));
+             p.first != p.second;
+             ++p.first)
+        {
+          const variable& var (p.first->first);
+
+          if (var.override ())
+            continue;
+
+          const value& val (p.first->second);
+
+          // Note: could be NULL if cfg.system.
+          //
+          const config_variable_value* v (cfg.find (var.name));
+
+          // The only situation where the result would not be acceptable is if
+          // one of the values were overridden to false.
+          //
+          pair<variable_origin, lookup> ol (
+            config::origin (rs,
+                            var,
+                            pair<lookup, size_t> {
+                              lookup {val, var, rs.vars}, 1 /* depth */}));
+
+          // An override cannot become a non-override. And a non-override
+          // cannot become an override. Except that the dependency override
+          // could be specified (only) for the dependent.
+          //
+          if (v != nullptr && v->origin == variable_origin::override_)
+          {
+            assert (ol.first == variable_origin::override_);
+          }
+          else if (ol.first == variable_origin::override_ &&
+                   (v == nullptr || v->origin != variable_origin::override_))
+          {
+            fail << "dependency override " << var.name << " specified for "
+                 << "dependent " << package.string () << " but not dependency" <<
+              info << "did you mean to specify ?" << cfg.package.name
+                 << " +{ " << var.name << "=... }";
+          }
+
+          if (ol.first == variable_origin::override_)
+          {
+            if (cfg.system)
+            {
+              try
+              {
+                if (!build2::convert<bool> (*ol.second))
+                  r = false;
+              }
+              catch (const invalid_argument&)
+              {
+                r = false;
+              }
+            }
+            else
+            {
+              if (!cast_false<bool> (*ol.second))
+                r = false;
+            }
+          }
+        }
+      }
+
+      // If acceptable, update the configuration with the new values, if any.
+      //
+      // Note that we cannot easily combine this loop with the above because
+      // we should not modify configurations if the result is not acceptable.
+      //
+      // We also save the subset of values that were set by this dependent to
+      // be reflected to further clauses.
+      //
+      if (r)
+      {
+        dependency_reflect_index_ = depends_index;
+        dependency_reflect_pending_ = dependency_reflect_.size ();
+
+        for (size_t i (0); i != cfgs.size (); ++i)
+        {
+          package_configuration& cfg (cfgs[i]);
+
+          const string& ns (dvps[i]);
+          for (auto p (rs.vars.lookup_namespace (ns));
+               p.first != p.second;
+               ++p.first)
+          {
+            const variable& var (p.first->first);
+
+            if (var.override ())
+              continue;
+
+            config_variable_value* v (cfg.find (var.name));
+
+            if (v == nullptr) // cfg.system
+            {
+              cfg.push_back (
+                config_variable_value {
+                  var.name, variable_origin::undefined, {}, {}, {}, false});
+              v = &cfg.back ();
+            }
+
+            // This value was set so save it as a dependency reflect.
+            //
+            // Note that unlike the equivalent evaluate_prefer_accept() logic,
+            // here the value cannot be the default/buildfile (since we don't
+            // set those; see the load() call above).
+            //
+            optional<names> ns (names {name ("true")});
+
+            // Note: force bool type if system.
+            //
+            dependency_reflect_.push_back (
+              reflect_variable_value {
+                v->name,
+                (v->origin == variable_origin::override_
+                 ? v->origin
+                 : variable_origin::buildfile),
+                cfg.system ? optional<string> ("bool") : v->type,
+                ns});
+
+            if (v->origin != variable_origin::override_)
+            {
+              // Possible transitions:
+              //
+              // default/undefine -> buildfile -- override dependency default
+              // buildfile        -> buildfile -- override other dependent
+              //
+
+              if (v->origin == variable_origin::buildfile)
+              {
+                // If unchanged, then we keep the old originating dependent
+                // (even if the value was technically "overwritten" by this
+                // dependent).
+                //
+                if (v->value == ns)
+                  continue;
+              }
+              else
+                v->origin = variable_origin::buildfile;
+
+              v->value = move (ns);
+              v->dependent = package; // We are the originating dependent.
+              v->confirmed = true;
+            }
+          }
+        }
+
+        dependency_var_prefixes_.insert (dependency_var_prefixes_.end (),
+                                         make_move_iterator (dvps.begin ()),
+                                         make_move_iterator (dvps.end ()));
+      }
+
+      // Drop the build system state since it needs reloading (while it may
+      // seem safe for us to keep the state since we didn't set any defaults,
+      // we may have overrides that the clause did not set, so let's drop it
+      // for good measure and also to keep things simple).
       //
       ctx_ = nullptr;
+
+      return r;
     }
     catch (const build2::failed&)
     {
@@ -561,75 +2155,649 @@ namespace bpkg
     }
   }
 
-  pair<strings, vector<optional<config_source>>> package_skeleton::
-  collect_config () &&
+  bool package_skeleton::
+  empty_print ()
   {
-    // Note that if the reflect variables list is not empty, then it also
-    // contains the user-specified configuration variables, which all come
-    // first (see above).
+    if (!loaded_old_config_)
+      load_old_config ();
+
+    return (dependent_vars_.empty () &&
+            reflect_.empty ()        &&
+            find_if (config_vars_.begin (), config_vars_.end (),
+                     [this] (const string& v)
+                     {
+                       // See print_config() for details.
+                       //
+                       size_t vn;
+                       if (project_override (v, var_prefix_, &vn))
+                       {
+                         if (!develop_)
+                         {
+                           size_t pn (var_prefix_.size ());
+                           if (v.compare (pn, vn - pn, ".develop") == 0)
+                             return false;
+                         }
+
+                         return true;
+                       }
+                       return false;
+                     }) == config_vars_.end ());
+  }
+
+  void package_skeleton::
+  print_config (ostream& os, const char* indent)
+  {
+    using build2::config::variable_origin;
+
+    if (!loaded_old_config_)
+      load_old_config ();
+
+    auto print = [&os,
+                  indent,
+                  first = true] (const string& v) mutable -> ostream&
+    {
+      if (first)
+        first = false;
+      else
+        os << '\n';
+
+      os << indent << v;
+      return os;
+    };
+
+    // NOTE: see also empty_print() if changing anything here.
+
+    // @@ TODO: we could have added the package itself to "set by ..."
+    //    for overriden (to the same value) reflect. But then why not
+    //    do the same for dependent that is overriden by user (we could
+    //    have kept them as reflect_variable_values rather than strings)?
+    //    Maybe one day.
+
+    // First comes the user configuration.
     //
-    size_t nc (config_vars_.size ());
+    for (const string& v: config_vars_)
+    {
+      size_t vn;
+      if (project_override (v, var_prefix_, &vn))
+      {
+        // To reduce the noise (e.g., during bdep-init), skip
+        // config.<project>.develop if the package doesn't use it.
+        //
+        if (!develop_)
+        {
+          size_t pn (var_prefix_.size ());
+          if (v.compare (pn, vn - pn, ".develop") == 0)
+            continue;
+        }
 
-    strings vars (reflect_vars_.empty ()
-                  ? move (config_vars_)
-                  : move (reflect_vars_));
+        print (v) << " (" << (system ? "expected " : "")
+                  << "user configuration)";
+      }
+    }
 
-    vector<optional<config_source>> sources;
+    // Next dependent configuration.
+    //
+    for (size_t i (0); i != dependent_vars_.size (); ++i)
+    {
+      const string& v (dependent_vars_[i]);
+      const package_key& d (dependent_orgs_[i]); // Parallel.
+
+      print (v) << " (" << (system ? "expected" : "set") << " by "
+                << d << ')';
+    }
+
+    // Finally reflect (but skip overriden).
+    //
+    for (const reflect_variable_value& v: reflect_)
+    {
+      if (v.origin == variable_origin::override_)
+        continue;
+
+      string s (serialize_cmdline (v.name, v.value));
+      print (s) << " (" << (system ? "expected" : "set") << " by "
+                << package.name << ')';
+    }
+  }
+
+  pair<strings, vector<config_variable>> package_skeleton::
+  collect_config () &&
+  {
+    assert (db_ != nullptr); // Must be called only once.
+
+    using build2::config::variable_origin;
+
+    if (!loaded_old_config_)
+      load_old_config ();
+
+    // Merge all the variables into a single list in the correct order
+    // and assign their sources while at it.
+    //
+    strings vars;
+    vector<config_variable> srcs;
 
-    if (!vars.empty ())
+    if (size_t n = (config_vars_.size () +
+                    dependent_vars_.size () +
+                    reflect_.size ()))
     {
-      sources.reserve (vars.size ());
+      // For vars we will steal the first non-empty *_vars_. But for sources
+      // reserve the space.
+      //
+      srcs.reserve (n); // At most that many.
 
-      // Assign the user source to only those user-specified configuration
-      // variables which are project variables (i.e., names start with
-      // config.<project>). Assign the reflect source to all variables that
-      // follow the user-specified configuration variables (which can only be
-      // project variables).
+      // Return the variable name given the variable override.
       //
-      // Note that some user-specified variables may have qualifications
-      // (global, scope, etc) but there is no reason to expect any project
-      // configuration variables to use such qualifications (since they can
-      // only apply to one project). So we skip all qualified variables.
+      auto var_name = [] (const string& v)
+      {
+        size_t p (v.find_first_of ("=+ \t"));
+        assert (p != string::npos);
+        return string (v, 0, p);
+      };
+
+      // Note that we assume the three sets of variables do not clash.
       //
-      string p ("config." + name ().variable ());
-      size_t n (p.size ());
 
-      for (const string& v: vars)
+      // First comes the user configuration.
+      //
+      if (!config_vars_.empty ())
       {
-        if (sources.size () < nc)
+        // Assign the user source only to user-specified configuration
+        // variables which are project variables (i.e., names start with
+        // config.<project>).
+        //
+        for (const string& v: config_vars_)
         {
-          if (v.compare (0, n, p) == 0 && strchr (".=+ \t", v[n]) != nullptr)
-            sources.push_back (config_source::user);
-          else
-            sources.push_back (nullopt);
+          if (project_override (v, var_prefix_))
+          {
+            string n (var_name (v));
+
+            // Check for a duplicate.
+            //
+            auto i (find_if (srcs.begin (), srcs.end (),
+                             [&n] (const config_variable& cv)
+                             {
+                               return cv.name == n;
+                             }));
+
+            if (i == srcs.end ())
+              srcs.push_back (config_variable {move (n), config_source::user});
+          }
         }
+
+        vars = move (config_vars_);
+      }
+
+      // Next dependent configuration.
+      //
+      if (!dependent_vars_.empty ())
+      {
+        // These are all project variables. There should also be no duplicates
+        // by construction.
+        //
+        for (const string& v: dependent_vars_)
+          srcs.push_back (
+            config_variable {var_name (v), config_source::dependent});
+
+        if (vars.empty ())
+          vars = move (dependent_vars_);
         else
-          sources.push_back (config_source::reflect);
+        {
+          vars.reserve (n);
+          vars.insert (vars.end (),
+                       make_move_iterator (dependent_vars_.begin ()),
+                       make_move_iterator (dependent_vars_.end ()));
+        }
       }
-    }
 
-    assert (db_ != nullptr);
+      // Finally reflect.
+      //
+      if (!reflect_.empty ())
+      {
+        vars.reserve (n);
 
-    ctx_ = nullptr; // In case we only had conditions.
+        // These are all project variables. There should also be no duplicates
+        // by construction (see evaluate_reflect()).
+        //
+        for (const reflect_variable_value& v: reflect_)
+        {
+          if (v.origin == variable_origin::override_)
+            continue;
+
+          vars.push_back (serialize_cmdline (v.name, v.value));
+          srcs.push_back (config_variable {v.name, config_source::reflect});
+        }
+      }
+    }
 
+    ctx_ = nullptr; // Free.
     db_ = nullptr;
-    available_ = nullptr;
 
-    return make_pair (move (vars), move (sources));
+    return make_pair (move (vars), move (srcs));
+  }
+
+  const strings& package_skeleton::
+  merge_cmd_vars (const strings& dependent_vars,
+                  const strings& dependency_vars,
+                  bool cache)
+  {
+    // Merge variable overrides (note that the order is important). See also a
+    // custom/optimized version in load_old_config().
+    //
+    if (!cache || !cmd_vars_cache_)
+    {
+      const strings& vs1 (build2_cmd_vars);
+      const strings& vs2 (config_vars_);
+      const strings& vs3 (dependent_vars);  // Should not override.
+      const strings& vs4 (dependency_vars); // Should not override.
+
+      // Try to reuse both vector and string buffers.
+      //
+      cmd_vars_.resize (
+        1 + vs1.size () + vs2.size () + vs3.size () + vs4.size ());
+
+      size_t i (0);
+      {
+        string& v (cmd_vars_[i++]);
+
+        // If the package is being disfigured, then don't load config.build at
+        // all. Otherwise, disfigure all package variables (config.<name>**).
+        //
+        // Note that this semantics must be consistent with how we actually
+        // configure the package in pkg_configure().
+        //
+        if (disfigure_)
+          v = "config.config.unload=true";
+        else
+        {
+          // Note: must be quoted to preserve the pattern.
+          //
+          v = "config.config.disfigure='config.";
+          v += package.name.variable ();
+          v += "**'";
+        }
+      }
+
+      for (const string& v: vs1) cmd_vars_[i++] = v;
+      for (const string& v: vs2) cmd_vars_[i++] = v;
+      for (const string& v: vs3) cmd_vars_[i++] = v;
+      for (const string& v: vs4) cmd_vars_[i++] = v;
+
+      cmd_vars_cache_ = cache;
+    }
+
+    return cmd_vars_;
+  }
+
+  void package_skeleton::
+  load_old_config ()
+  {
+    assert (!loaded_old_config_ && ctx_ == nullptr);
+
+    try
+    {
+      using namespace build2;
+
+      // This load that must be done without config.config.disfigure. Also, it
+      // would be nice to optimize for the common case where the only load is
+      // to get the old configuration (e.g., config.*.develop) as part of
+      // collect_config(). So instead of calling merge_cmd_vars() we will do
+      // our own (but consistent) thing.
+      //
+      const strings* cmd_vars (nullptr);
+      {
+        assert (!cmd_vars_cache_); // Sanity check (we are always first).
+
+        const strings& vs1 (build2_cmd_vars);
+        const strings& vs2 (config_vars_);
+
+        if (!disfigure_)
+          cmd_vars = (vs2.empty () ? &vs1 : vs1.empty () ? &vs2 : nullptr);
+
+        if (cmd_vars == nullptr)
+        {
+          // Note: the order is important (see merge_cmd_vars()).
+          //
+          cmd_vars_.reserve ((disfigure_ ? 1 : 0) + vs1.size () + vs2.size ());
+
+          // If the package is being disfigured, then don't load config.build
+          // at all.
+          //
+          if (disfigure_)
+            cmd_vars_.push_back ("config.config.unload=true");
+
+          cmd_vars_.insert (cmd_vars_.end (), vs1.begin (), vs1.end ());
+          cmd_vars_.insert (cmd_vars_.end (), vs2.begin (), vs2.end ());
+
+          cmd_vars = &cmd_vars_;
+        }
+      }
+
+      scope& rs (*bootstrap (*this, *cmd_vars)->second.front ());
+
+      // Load project's root.build.
+      //
+      load_root (rs);
+
+      if (const variable* var = rs.var_pool ().find (var_prefix_ + ".develop"))
+      {
+        // Use the fact that the variable is typed as a proxy for it being
+        // defined with config directive (the more accurate way would be via
+        // the config module's saved variables map).
+        //
+        develop_ = (var->type != nullptr);
+      }
+
+      // @@ TODO: should we also verify user-specified project configuration
+      //    variables are not bogus? But they could be untyped...
+      //
+      //    Also, build2 warns about unused variables being dropped.
+      //
+      //    Note that currently load_old_config() is disabled unless there is
+      //    a config.*.develop variable; see package_skeleton ctor.
+
+      // Extract and merge old user configuration variables from config.build
+      // (or equivalent) into config_vars.
+      //
+      if (config_srcs_ != nullptr)
+      {
+        assert (!disfigure_);
+
+        auto i (config_vars_.begin ()); // Insert position, see below.
+
+        names storage;
+        for (const config_variable& v: *config_srcs_)
+        {
+          if (v.source != config_source::user)
+            continue;
+
+          using config::variable_origin;
+
+          pair<variable_origin, lookup> ol (config::origin (rs, v.name));
+
+          switch (ol.first)
+          {
+          case variable_origin::override_:
+            {
+              // Already in config_vars.
+              //
+              // @@ TODO: theoretically, this could be an append/prepend
+              //    override(s) and to make this work correctly we would need
+              //    to replace them with an assign override with the final
+              //    value. Maybe one day.
+              //
+              break;
+            }
+          case variable_origin::buildfile:
+            {
+              // Doesn't really matter where we add them though conceptually
+              // feels like old should go before new (and in the original
+              // order).
+              //
+              i = config_vars_.insert (
+                i,
+                serialize_cmdline (v.name, *ol.second, storage)) + 1;
+
+              break;
+            }
+          case variable_origin::undefined:
+          case variable_origin::default_:
+            {
+              // Old user configuration no longer in config.build. We could
+              // complain but that feels overly drastic. Seeing that we will
+              // recalculate the new set of config variable sources, let's
+              // just ignore this (we could issue a warning, but who knows how
+              // many times it will be issued with all this backtracking).
+              //
+              break;
+            }
+          }
+        }
+      }
+
+      loaded_old_config_ = true;
+      verified_ = true; // Managed to load without errors.
+      ctx_ = nullptr;
+    }
+    catch (const build2::failed&)
+    {
+      throw failed (); // Assume the diagnostics has already been issued.
+    }
   }
 
   build2::scope& package_skeleton::
-  load ()
+  load (const dependency_configurations& cfgs, strings* dvps, bool defaults)
   {
     if (ctx_ != nullptr)
-      return *rs_;
+    {
+      // We have to reload if there is any dependency configuration.
+      //
+      if (cfgs.empty ())
+        return *rs_;
+
+      ctx_ = nullptr;
+    }
+
+    if (!loaded_old_config_)
+      load_old_config ();
+
+    try
+    {
+      using namespace build2;
+      using build2::config::variable_origin;
+
+      // If we have any dependency configurations, then here we need to add
+      // dependency configuration variables with the override origin to the
+      // command line overrides (see evaluate_prefer_accept() for details).
+      // While at it, handle dependency variable prefixes.
+      //
+      strings dependency_vars;
+      for (const package_configuration& cfg: cfgs)
+      {
+        for (const config_variable_value& v: cfg)
+        {
+          if (v.origin == variable_origin::override_)
+            dependency_vars.push_back (v.serialize_cmdline ());
+        }
+
+        string p ("config." + cfg.package.name.variable ());
+
+        auto i (find (dependency_var_prefixes_.begin (),
+                      dependency_var_prefixes_.end (),
+                      p));
+        if (i != dependency_var_prefixes_.end ())
+          dependency_var_prefixes_.erase (i);
+
+        dvps->push_back (move (p));
+      }
+
+      // If there aren't any, then we can reuse already merged cmd_vars (they
+      // don't change during evaluate_*() calls except for the dependency
+      // overrides case).
+      //
+      const strings& cmd_vars (
+        merge_cmd_vars (dependent_vars_,
+                        dependency_vars,
+                        dependency_vars.empty () /* cache */));
+
+      auto rsi (bootstrap (*this, cmd_vars));
+      scope& rs (*rsi->second.front ());
+
+      // Load project's root.build as well as potentially accumulated reflect
+      // variables.
+      //
+      // If we have the accumulated reflect variables, wedge them just before
+      // loading root.build (but after initializing config which may load
+      // config.build and which we wish to override).
+      //
+      // Note that the plan for non-external packages is to extract the
+      // configuration and then load it with config.config.load and this
+      // approach should work for that case too.
+      //
+      // This is also where we set dependency configuration variables with the
+      // default and buildfile origins and typify all dependency variables
+      // (see evaluate_prefer_accept() for details).
+      //
+      function<void (parser&)> pre;
+
+      struct data
+      {
+        scope& rs;
+        const dependency_configurations& cfgs;
+        bool defaults;
+      } d {rs, cfgs, defaults};
+
+      if (!cfgs.empty ()     ||
+          !reflect_.empty () ||
+          !dependency_reflect_.empty ())
+      {
+        pre = [this, &d] (parser&)
+        {
+          scope& rs (d.rs);
+
+          auto insert_var = [&rs] (const string& name,
+                                   const optional<string>& type)
+            -> const variable&
+          {
+            const value_type* vt (nullptr);
+            if (type)
+            {
+              vt = parser::find_value_type (&rs, *type);
+              assert (vt != nullptr);
+            }
+
+            return rs.var_pool ().insert (name, vt);
+          };
+
+          for (const reflect_variable_value& v: reflect_)
+          {
+            if (v.origin == variable_origin::override_)
+              continue;
+
+            const variable& var (insert_var (v.name, v.type)); // Note: untyped.
+            value& val (rs.assign (var));
+
+            if (v.value)
+              val.assign (names (*v.value), &var);
+            else
+              val = nullptr;
+          }
+
+          // Note that for now we don't bother setting overridden reflect
+          // values as overrides. It seems the only reason to go through the
+          // trouble would be to get the accurate $origin() result. But basing
+          // any decisions on whether the reflect value was overridden or not
+          // seems far fetched.
+          //
+          for (const reflect_variable_value& v: dependency_reflect_)
+          {
+            const variable& var (insert_var (v.name, v.type));
+            value& val (rs.assign (var));
+
+            if (v.value)
+              val.assign (names (*v.value), &var);
+            else
+              val = nullptr;
+          }
+
+          for (const package_configuration& cfg: d.cfgs)
+          {
+            for (const config_variable_value& v: cfg)
+            {
+              const variable& var (insert_var (v.name, v.type));
+
+              switch (v.origin)
+              {
+              case variable_origin::default_:
+              case variable_origin::buildfile:
+                {
+                  if (d.defaults)
+                  {
+                    auto& val (
+                      static_cast<variable_map::value_data&> (
+                        rs.assign (var)));
+
+                    if (v.value)
+                      val.assign (names (*v.value), &var);
+                    else
+                      val = nullptr;
+
+                    val.extra = v.origin == variable_origin::default_ ? 1 : 2;
+                  }
+                  break;
+                }
+              case variable_origin::undefined:
+              case variable_origin::override_: break;
+              }
+            }
+          }
+        };
+      }
+
+      load_root (rs, pre);
+
+      setup_base (rsi,
+                  out_root_.empty () ? src_root_ : out_root_,
+                  src_root_);
+
+      rs_ = &rs;
+      return rs;
+    }
+    catch (const build2::failed&)
+    {
+      throw failed (); // Assume the diagnostics has already been issued.
+    }
+  }
+
+  // Create the build context.
+  //
+  static void
+  create_context (package_skeleton& skl, const strings& cmd_vars)
+  {
+    assert (skl.db_ != nullptr && skl.ctx_ == nullptr);
+
+    // Initialize the build system.
+    //
+    if (!build2_sched.started ())
+      build2_init (*skl.co_);
+
+    try
+    {
+      using namespace build2;
+      using build2::fail;
+      using build2::endf;
+
+      // Create build context.
+      //
+      skl.ctx_.reset (
+        new context (build2_sched,
+                     build2_mutexes,
+                     build2_fcache,
+                     false /* match_only */,          // Shouldn't matter.
+                     false /* no_external_modules */,
+                     false /* dry_run */,             // Shouldn't matter.
+                     false /* keep_going */,          // Shouldnt' matter.
+                     cmd_vars));
+    }
+    catch (const build2::failed&)
+    {
+      throw failed (); // Assume the diagnostics has already been issued.
+    }
+  }
+
+  // Bootstrap the package skeleton.
+  //
+  static build2::scope_map::iterator
+  bootstrap (package_skeleton& skl, const strings& cmd_vars)
+  {
+    assert (skl.db_ != nullptr       &&
+            skl.ctx_ == nullptr      &&
+            skl.available != nullptr);
 
     // The overall plan is as follows:
     //
     // 0. Create filesystem state if necessary (could have been created by
     //    another instance, e.g., during simulation).
     //
-    // 1. Load the state potentially with accumulated reflect fragment.
+    // 1. Bootstrap the package skeleton.
     //
     // Creating a new context is not exactly cheap (~1.2ms debug, 0.08ms
     // release) so we could try to re-use it by cleaning all the scopes other
@@ -640,22 +2808,22 @@ namespace bpkg
 
     // Create the skeleton filesystem state, if it doesn't exist yet.
     //
-    if (!created_)
+    if (!skl.created_)
     {
-      const available_package& ap (*available_);
+      const available_package& ap (*skl.available);
 
       // Note that we create the skeleton directories in the skeletons/
       // subdirectory of the configuration temporary directory to make sure
       // they never clash with other temporary subdirectories (git
       // repositories, etc).
       //
-      if (src_root_.empty () || out_root_.empty ())
+      if (skl.src_root_.empty () || skl.out_root_.empty ())
       {
         // Cannot be specified if src_root_ is unspecified.
         //
-        assert (out_root_.empty ());
+        assert (skl.out_root_.empty ());
 
-        auto i (tmp_dirs.find (db_->config_orig));
+        auto i (tmp_dirs.find (skl.db_->config_orig));
         assert (i != tmp_dirs.end ());
 
         // Make sure the source and out root directories, if set, are absolute
@@ -667,15 +2835,15 @@ namespace bpkg
         dir_path d (normalize (i->second, "temporary directory"));
 
         d /= "skeletons";
-        d /= name ().string () + '-' + ap.version.string ();
+        d /= skl.package.name.string () + '-' + ap.version.string ();
 
-        if (src_root_.empty ())
-          src_root_ = move (d); // out_root_ is the same.
+        if (skl.src_root_.empty ())
+          skl.src_root_ = move (d); // out_root_ is the same.
         else
-          out_root_ = move (d); // Don't even need to create it.
+          skl.out_root_ = move (d); // Don't even need to create it.
       }
 
-      if (!exists (src_root_))
+      if (!exists (skl.src_root_))
       {
         // Create the buildfiles.
         //
@@ -684,7 +2852,7 @@ namespace bpkg
         // additional files.
         //
         {
-          path bf (src_root_ / std_bootstrap_file);
+          path bf (skl.src_root_ / std_bootstrap_file);
 
           mk_p (bf.directory ());
 
@@ -707,7 +2875,7 @@ namespace bpkg
           save (*ap.bootstrap_build, bf);
 
           if (ap.root_build)
-            save (*ap.root_build, src_root_ / std_root_file);
+            save (*ap.root_build, skl.src_root_ / std_root_file);
         }
 
         // Create the manifest file containing the bare minimum of values
@@ -716,7 +2884,7 @@ namespace bpkg
         //
         {
           package_manifest m;
-          m.name = name ();
+          m.name = skl.package.name;
           m.version = ap.version;
 
           // Note that there is no guarantee that the potential build2
@@ -738,7 +2906,7 @@ namespace bpkg
               m.dependencies.push_back (das);
           }
 
-          path mf (src_root_ / manifest_file);
+          path mf (skl.src_root_ / manifest_file);
 
           try
           {
@@ -763,58 +2931,19 @@ namespace bpkg
         }
       }
 
-      created_ = true;
+      skl.created_ = true;
     }
 
-    // Initialize the build system.
-    //
-    if (!build2_sched.started ())
-      build2_init (*co_);
-
     try
     {
       using namespace build2;
       using build2::fail;
       using build2::endf;
 
-      // Create build context.
-      //
-      // We can reasonably assume reflect cannot have global or absolute scope
-      // variable overrides so we don't need to pass them to context.
-
-      // Merge variable overrides (note that the order is important).
+      // Create the build context.
       //
-      strings* cmd_vars;
-      {
-        strings& v1 (build2_cmd_vars);
-        strings& v2 (config_vars_);
-
-        cmd_vars = (v2.empty () ? &v1 : v1.empty () ? &v2 : nullptr);
-
-        if (cmd_vars == nullptr)
-        {
-          if (cmd_vars_.empty ()) // Cached.
-          {
-            cmd_vars_.reserve (v1.size () + v2.size ());
-            cmd_vars_.assign (v1.begin (), v1.end ());
-            cmd_vars_.insert (cmd_vars_.end (), v2.begin (), v2.end ());
-          }
-
-          cmd_vars = &cmd_vars_;
-        }
-      }
-
-      ctx_.reset (
-        new context (build2_sched,
-                     build2_mutexes,
-                     build2_fcache,
-                     false /* match_only */,          // Shouldn't matter.
-                     false /* no_external_modules */,
-                     false /* dry_run */,             // Shouldn't matter.
-                     false /* keep_going */,          // Shouldnt' matter.
-                     *cmd_vars));
-
-      context& ctx (*ctx_);
+      create_context (skl, cmd_vars);
+      context& ctx (*skl.ctx_);
 
       // This is essentially a subset of the steps we perform in b.cxx. See
       // there for more detailed comments.
@@ -835,8 +2964,10 @@ namespace bpkg
 
       // Note that it's ok for out_root to not exist (external package).
       //
-      const dir_path& src_root (src_root_);
-      const dir_path& out_root (out_root_.empty () ? src_root_ : out_root_);
+      const dir_path& src_root (skl.src_root_);
+      const dir_path& out_root (skl.out_root_.empty ()
+                                ? skl.src_root_
+                                : skl.out_root_);
 
       auto rsi (create_root (ctx, out_root, src_root));
       scope& rs (*rsi->second.front ());
@@ -849,16 +2980,31 @@ namespace bpkg
       if (!v)
         v = src_root;
       else
-        assert (cast<dir_path> (v) == src_root);
+      {
+        // If the package directory was moved, then it's possible we will have
+        // src-root.build with an old src_root value. Presumably this will
+        // cause the package to be re-configured and so ignoring the old value
+        // here should be ok. Note that the outdated src-root.build can also
+        // mess up subproject discovery in create_bootstrap_outer() but we
+        // omit that part.
+        //
+        if (cast<dir_path> (v) != src_root)
+          v = src_root;
+      }
 
       setup_root (rs, false /* forwarded */);
 
       bootstrap_pre (rs, altn);
       bootstrap_src (rs, altn,
-                     db_->config.relative (out_root) /* amalgamation */,
-                     false                           /* subprojects */);
+                     skl.db_->config.relative (out_root) /* amalgamation */,
+                     false                               /* subprojects */);
 
-      create_bootstrap_outer (rs);
+
+      // Omit discovering amalgamation's subprojects (i.e., all the packages
+      // in the configuration). Besides being a performance optimization, this
+      // also sidesteps the issue of outdated src-root.build (see above).
+      //
+      create_bootstrap_outer (rs, false /* subprojects */);
       bootstrap_post (rs);
 
       assert (mif.meta_operation_pre == nullptr);
@@ -866,41 +3012,7 @@ namespace bpkg
 
       ctx.enter_project_overrides (rs, out_root, ctx.var_overrides);
 
-      // Load project's root.build.
-      //
-      // If we have the accumulated reflect fragment, wedge it just before
-      // loading root.build (but after initializing config which may load
-      // config.build and which we wish to override).
-      //
-      // Note that the plan for non-external packages is to extract the
-      // configuration and then load it with config.config.load and this
-      // approach should work for that case too.
-      //
-      function<void (parser&)> pre;
-
-      if (!reflect_frag_.empty ())
-      {
-        pre = [this, &rs] (parser& p)
-        {
-          istringstream is (reflect_frag_);
-          is.exceptions (istringstream::failbit | istringstream::badbit);
-
-          // Note that the fragment is just a bunch of variable assignments
-          // and thus unlikely to cause any errors.
-          //
-          path_name in ("<accumulated-reflect-fragment>");
-          p.parse_buildfile (is, in, &rs, rs);
-        };
-      }
-
-      load_root (rs, pre);
-
-      // Setup root scope as base.
-      //
-      setup_base (rsi, out_root, src_root);
-
-      rs_ = &rs;
-      return rs;
+      return rsi;
     }
     catch (const build2::failed&)
     {
diff --git a/bpkg/package-skeleton.hxx b/bpkg/package-skeleton.hxx
index aaa9b8c..7224d1d 100644
--- a/bpkg/package-skeleton.hxx
+++ b/bpkg/package-skeleton.hxx
@@ -4,12 +4,13 @@
 #ifndef BPKG_PACKAGE_SKELETON_HXX
 #define BPKG_PACKAGE_SKELETON_HXX
 
-#include <libbuild2/forward.hxx> // build2::context
+#include <libbuild2/forward.hxx>
 
 #include <bpkg/types.hxx>
 #include <bpkg/utility.hxx>
 
 #include <bpkg/package.hxx>
+#include <bpkg/package-configuration.hxx>
 #include <bpkg/common-options.hxx>
 
 namespace bpkg
@@ -20,6 +21,12 @@ namespace bpkg
   class package_skeleton
   {
   public:
+    // If the package is system, then its available package should be NULL if
+    // it doesn't match the system package version "close enough" to be usable
+    // as the source of its configuration information (types, defaults). If it
+    // is NULL, then the skeleton can only be used to print and collect the
+    // configuration information.
+    //
     // If the package is external, then the existing package source root
     // directory needs to be specified (as absolute and normalized). In this
     // case, if output root is specified (as absolute and normalized; normally
@@ -29,50 +36,152 @@ namespace bpkg
     // If the package is not external, then none of the root directories
     // should be specified.
     //
-    // Note that the options, database, and available_package are expected to
+    // The disfigure argument should indicate whether the package is being
+    // reconfigured from scratch (--disfigure).
+    //
+    // The config_vars argument contains configuration variables specified by
+    // the user in this bpkg execution. Optional config_srcs is used to
+    // extract (from config.build or equivalent) configuration variables
+    // specified by the user in previous bpkg executions. It should be NULL if
+    // this is the first build of the package. The extracted variables are
+    // merged with config_vars and the combined result is returned by
+    // collect_config() below.
+    //
+    // @@ TODO: speaking of the "config.build or equivalent" part, the
+    //    equivalent is likely to be extracted configuration (probably saved
+    //    to file in tmp somewhere) that we will load with config.config.load.
+    //    It doesn't seem like a good idea to pass it as part of config_vars
+    //    (because sometimes we may need to omit it) so most likely it will be
+    //    passed as a separate arguments (likely a file path).
+    //
+    // Note that the options, database, and config_srcs are expected to
     // outlive this object.
     //
     // Note also that this creates an "unloaded" skeleton and is therefore
     // relatively cheap.
     //
     package_skeleton (const common_options& co,
-                      database&,
-                      const available_package&,
+                      package_key,
+                      bool system,
+                      shared_ptr<const available_package>,
                       strings config_vars,
+                      bool disfigure,
+                      const vector<config_variable>* config_srcs,
                       optional<dir_path> src_root,
                       optional<dir_path> out_root);
 
-    // For the following evaluate_*() functions assume that the clause belongs
-    // to the specified (by index) depends value (used to print its location
-    // on failure for an external package).
+
+    package_key package;
+    bool system;
+    shared_ptr<const available_package> available;
+
+    // The following functions should be called in the following sequence
+    // (* -- zero or more, ? -- zero or one):
+    //
+    // * reload_defaults() | verify_sensible()
+    // ? dependent_config()
+    // * evaluate_*()
+    // * empty() | print_config()
+    //   collect_config()
+    //
+    // Note that a copy of the skeleton is expected to continue with the
+    // sequence rather than starting from scratch, unless reset() is called.
+    //
+  public:
+    // Reload the default values and type information for configuration
+    // variables using the values with the buildfile origin as a "tentative"
+    // dependent configuration.
+    //
+    void
+    reload_defaults (package_configuration&);
+
+    // Load overrides for a system package without skeleton info. Note that
+    // this is done in an ad hoc manner and only to support evaluate_require()
+    // semantics (see the implementation for details).
+    //
+    void
+    load_overrides (package_configuration&);
+
+    // Verify the specified "tentative" dependent configuration is sensible,
+    // that is, acceptable to the dependency itself. If it is not, then the
+    // second half of the result contains the diagnostics.
+    //
+    pair<bool, string>
+    verify_sensible (const package_configuration&);
+
+    // Incorporate the "final" dependent configuration into subsequent
+    // evaluations. Dependent configuration variables are expected not to
+    // clash with user.
     //
+    void
+    dependent_config (const package_configuration&);
+
+    // For the following evaluate_*() functions assume that the clause belongs
+    // to the dependency alternative specified as a pair of indexes (depends
+    // value index and alternative index).
+
     // Evaluate the enable clause.
     //
     bool
-    evaluate_enable (const string&, size_t depends_index);
+    evaluate_enable (const string&, pair<size_t, size_t>);
 
     // Evaluate the reflect clause.
     //
     void
-    evaluate_reflect (const string&, size_t depends_index);
+    evaluate_reflect (const string&, pair<size_t, size_t>);
+
+    // Evaluate the prefer/accept or require clauses on the specified
+    // dependency configurations (serves as both input and output).
+    //
+    // Return true is acceptable and false otherwise. If acceptable, the
+    // passed configuration is updated with new values, if any.
+    //
+    using dependency_configurations =
+      small_vector<reference_wrapper<package_configuration>, 1>;
+
+    bool
+    evaluate_prefer_accept (const dependency_configurations&,
+                            const string&, const string&, pair<size_t, size_t>);
+
+    bool
+    evaluate_require (const dependency_configurations&,
+                      const string&, pair<size_t, size_t>);
+
+    // Reset the skeleton to the start of the call sequence.
+    //
+    // Note that this function cannot be called after collect_config().
+    //
+    void
+    reset ();
 
-    // Return the accumulated reflect values together with their sources (the
-    // resulting vectors are parallel).
+    // Return true if there are no accumulated *project* configuration
+    // variables that will be printed by print_config().
     //
-    // Note that the result is merged with config_vars and should be used
-    // instead rather than in addition to config_vars. The source of
-    // configuration variables which are not the project variables is absent.
+    bool
+    empty_print ();
+
+    // Print the accumulated *project* configuration variables as command line
+    // overrides one per line with the specified indentation.
+    //
+    void
+    print_config (ostream&, const char* indent);
+
+    // Return the accumulated configuration variables (first) and project
+    // configuration variable sources (second). Note that the arrays are not
+    // necessarily parallel (config_vars may contain non-project variables).
+    //
+    // Note that the dependent and reflect variables are merged with
+    // config_vars/config_srcs and should be used instead rather than in
+    // addition to config_vars.
     //
     // Note also that this should be the final call on this object.
     //
-    pair<strings, vector<optional<config_source>>>
+    pair<strings, vector<config_variable>>
     collect_config () &&;
 
-    const package_name&
-    name () const {return available_->id.name;}
-
     // Implementation details.
     //
+  public:
     // We have to define these because context is forward-declared. Also, copy
     // constructor has some special logic.
     //
@@ -84,32 +193,146 @@ namespace bpkg
     package_skeleton& operator= (const package_skeleton&) = delete;
 
   private:
-    // Create the skeleton if necessary and (re)load the build system state.
+    // Load old user configuration variables from config.build (or equivalent)
+    // and merge them into config_vars_. Also verify new user configuration
+    // already in config_vars_ makes sense.
+    //
+    // This should be done before any attempt to load the configuration with
+    // config.config.disfigure and, if this did not happen, inside
+    // collect_config() (since the package will be reconfigured with
+    // config.config.disfigure).
+    //
+    void
+    load_old_config ();
+
+    // (Re)load the build system state.
     //
     // Call this function before evaluating every clause.
     //
+    // If dependency configurations are specified, then typify the variables
+    // and set their values. If defaults is false, then only typify the
+    // variables and set overrides without setting the default/buildfile
+    // values. Note that buildfile values have value::extra set to 2. While
+    // at it, also remove from dependency_var_prefixes_ and add to
+    // dependency_var_prefixes variable prefixes (config.<project>) for
+    // the passed dependencies.
+    //
     build2::scope&
-    load ();
+    load (const dependency_configurations& = {},
+          strings* dependency_var_prefixes = nullptr,
+          bool defaults = true);
 
-  private:
+    // Merge command line variable overrides into one list (normally to be
+    // passed to bootstrap()).
+    //
+    // If cache is true, then assume the result can be reused on subsequent
+    // calls.
+    //
+    const strings&
+    merge_cmd_vars (const strings& dependent_vars,
+                    const strings& dependency_vars = {},
+                    bool cache = false);
+
+    // Implementation details (public for bootstrap()).
+    //
+  public:
     // NOTE: remember to update move/copy constructors!
     //
     const common_options* co_;
     database* db_;
-    const available_package* available_;
+
+    string var_prefix_; // config.<project>
+
     strings config_vars_;
+    bool disfigure_;
+    const vector<config_variable>* config_srcs_; // NULL if nothing to do or
+                                                 // already done.
 
     dir_path src_root_; // Must be absolute and normalized.
     dir_path out_root_; // If empty, the same as src_root_.
 
     bool created_ = false;
+    bool verified_ = false;
+    bool loaded_old_config_;
+    bool develop_ = true;  // Package has config.*.develop.
+
     unique_ptr<build2::context> ctx_;
     build2::scope* rs_ = nullptr;
-    strings cmd_vars_; // Storage for merged build2_cmd_vars and config_vars_.
 
-    strings reflect_names_; // Reflect configuration variable names.
-    strings reflect_vars_;  // Reflect configuration variable overrides.
-    string  reflect_frag_;  // Reflect configuration variable fragment.
+    // Storage for merged build2_cmd_vars and config_vars_ and extra overrides
+    // (like config.config.disfigure). If cache is true, then the existing
+    // content can be reused.
+    //
+    strings cmd_vars_;
+    bool cmd_vars_cache_ = false;
+
+    strings             dependent_vars_; // Dependent variable overrides.
+    vector<package_key> dependent_orgs_; // Dependent originators (parallel).
+
+    // Reflect variable value storage. Used for both real reflect and
+    // dependency reflect.
+    //
+    struct reflect_variable_value
+    {
+      string                          name;
+      build2::config::variable_origin origin;
+      optional<string>                type;
+      optional<build2::names>         value;
+    };
+
+    class reflect_variable_values: public vector<reflect_variable_value>
+    {
+    public:
+      const reflect_variable_value*
+      find (const string& name)
+      {
+        auto i (find_if (begin (), end (),
+                         [&name] (const reflect_variable_value& v)
+                         {
+                           return v.name == name;
+                         }));
+        return i != end () ? &*i : nullptr;
+      }
+    };
+
+    reflect_variable_values reflect_; // Reflect variables.
+
+    // Dependency configuration variables set by the prefer/require clauses
+    // and that should be reflected in subsequent clauses.
+    //
+    // The same prefer/require clause could be re-evaluated multiple times in
+    // which case the previous dependency reflect values from this clause (but
+    // not from any previous clauses) should be dropped. This is achieved by
+    // keeping track of the depends_index for the most recently evaluated
+    // prefer/require clause along with the position of the first element that
+    // was added by this clause. Note also that this logic does the right
+    // thing if we move to a different dependency alternative withing the same
+    // depends value.
+    //
+    reflect_variable_values dependency_reflect_;
+    size_t                  dependency_reflect_index_ = 0;
+    size_t                  dependency_reflect_pending_ = 0;
+
+    // List of variable prefixes (config.<project>) of all known dependencies.
+    //
+    // This information is used to detect and diagnose references to undefined
+    // dependency configuration variables (for example, those that were not
+    // set and therefore not reflected). The pending index is used to ignore
+    // the entries added by the last evaluate_prefer_accept() in the following
+    // reflect clause (see prefer_accept_ below for details).
+    //
+    strings dependency_var_prefixes_;
+    size_t  dependency_var_prefixes_pending_ = 0;
+
+    // Position of the last successfully evaluated prefer/accept clauses.
+    //
+    // This information is used to make all (as opposed to only those set by
+    // the prefer clause) dependency configuration variables available to the
+    // reflect clause but only at the same position. This allows for some more
+    // advanced configuration techniques, such as, using a feature if enabled
+    // by someone else but not having any preferences ourselves.
+    //
+    optional<pair<size_t, size_t>> prefer_accept_;
   };
 }
 
diff --git a/bpkg/package.cxx b/bpkg/package.cxx
index 3a356f8..c02bdf4 100644
--- a/bpkg/package.cxx
+++ b/bpkg/package.cxx
@@ -53,17 +53,17 @@ namespace bpkg
       return path;
   }
 
-  // config_package
+  // package_key
   //
-  string config_package::
+  string package_key::
   string () const
   {
-    const std::string& s (db.string);
+    const std::string& s (db.get ().string);
     return !s.empty () ? name.string () + ' ' + s : name.string ();
   }
 
-  bool config_package::
-  operator< (const config_package& v) const
+  bool package_key::
+  operator< (const package_key& v) const
   {
     int r (name.compare (v.name));
     return r != 0 ? (r < 0) : (db < v.db);
@@ -827,7 +827,7 @@ namespace bpkg
   bool
   toolchain_buildtime_dependency (const common_options& o,
                                   const dependency_alternatives_ex& das,
-                                  const package_name& pkg)
+                                  const package_name* pkg)
   {
     if (das.buildtime)
     {
@@ -839,10 +839,10 @@ namespace bpkg
 
           if (dn == "build2")
           {
-            if (d.constraint && !satisfy_build2 (o, d))
+            if (pkg != nullptr && d.constraint && !satisfy_build2 (o, d))
             {
               fail << "unable to satisfy constraint (" << d << ") for "
-                   << "package " << pkg <<
+                   << "package " << *pkg <<
                 info << "available build2 version is " << build2_version;
             }
 
@@ -850,10 +850,10 @@ namespace bpkg
           }
           else if (dn == "bpkg")
           {
-            if (d.constraint && !satisfy_bpkg (o, d))
+            if (pkg != nullptr && d.constraint && !satisfy_bpkg (o, d))
             {
               fail << "unable to satisfy constraint (" << d << ") for "
-                   << "package " << pkg <<
+                   << "package " << *pkg <<
                 info << "available bpkg version is " << bpkg_version;
             }
 
@@ -865,4 +865,18 @@ namespace bpkg
 
     return false;
   }
+
+  bool
+  has_dependencies (const common_options& o,
+                    const dependencies& deps,
+                    const package_name* pkg)
+  {
+    for (const auto& das: deps)
+    {
+      if (!toolchain_buildtime_dependency (o, das, pkg))
+        return true;
+    }
+
+    return false;
+  }
 }
diff --git a/bpkg/package.hxx b/bpkg/package.hxx
index 7dc8e11..dc5031c 100644
--- a/bpkg/package.hxx
+++ b/bpkg/package.hxx
@@ -27,7 +27,7 @@
 //
 #define DB_SCHEMA_VERSION_BASE 7
 
-#pragma db model version(DB_SCHEMA_VERSION_BASE, 18, closed)
+#pragma db model version(DB_SCHEMA_VERSION_BASE, 19, closed)
 
 namespace bpkg
 {
@@ -580,17 +580,27 @@ namespace bpkg
                          make_move_iterator (das.end ()));
   }
 
-  // If this is a toolchain build-time dependency, then verify its constraint
-  // returning true if it is satisfied and failing otherwise. Return false for
-  // a regular dependency. Note that the package argument is used for
-  // diagnostics only.
+  // Return true if this is a toolchain build-time dependency. If the package
+  // argument is specified and this is a toolchain build-time dependency then
+  // also verify its constraint and fail if it is unsatisfied. Note that the
+  // package argument is used for diagnostics only.
   //
   class common_options;
 
   bool
   toolchain_buildtime_dependency (const common_options&,
                                   const dependency_alternatives_ex&,
-                                  const package_name&);
+                                  const package_name*);
+
+  // Return true if any dependency other than toolchain build-time
+  // dependencies is specified. Optionally, verify toolchain build-time
+  // dependencies specifying the package argument which will be used for
+  // diagnostics only.
+  //
+  bool
+  has_dependencies (const common_options&,
+                    const dependencies&,
+                    const package_name* = nullptr);
 
   // Return true if some clause that is a buildfile fragment is specified for
   // any of the dependencies.
@@ -1022,21 +1032,63 @@ namespace bpkg
   }
 
   // A map of "effective" prerequisites (i.e., pointers to other selected
-  // packages) to optional version constraint. Note that because it is a
-  // single constraint, we don't support multiple dependencies on the same
-  // package (e.g., two ranges of versions). See pkg_configure().
+  // packages) to optional version constraint (plus some other info). Note
+  // that because it is a single constraint, we don't support multiple
+  // dependencies on the same package (e.g., two ranges of versions). See
+  // pkg_configure().
   //
   // Note also that the pointer can refer to a selected package in another
   // database.
   //
   class selected_package;
 
+  #pragma db value
+  struct prerequisite_info
+  {
+    // The "tightest" version constraint among all dependencies resolved to
+    // this prerequisite.
+    //
+    optional<version_constraint> constraint;
+
+    // Position of the first dependency alternative with a configuration
+    // clause, if any.
+    //
+    // Specifically, if there is such an alternative then this is a pair of
+    // 1-based indexes of the respective depends value (first) and the
+    // dependency alternative (second) in the dependent's manifest. Otherwise,
+    // this is a pair of zeros.
+    //
+    // For example, for the following dependent the position for libfoo/1.2.0
+    // prerequisite will be {2,2}:
+    //
+    // libbar: depends: libfoo >= 1.1.0
+    //         depends: libfox | libfoo >= 1.2.0 {require {...}}
+    //
+    pair<size_t, size_t> config_position;
+
+    // Database mapping.
+    //
+    #pragma db member(constraint) column("")
+
+    #pragma db member(config_position) transient
+
+    #pragma db member(config_dependency_index) \
+      virtual(size_t)                          \
+      access(config_position.first)            \
+      default(0)
+
+    #pragma db member(config_alternative_index) \
+      virtual(size_t)                           \
+      access(config_position.second)            \
+      default(0)
+  };
+
   // Note that the keys for this map need to be created with the database
   // passed to their constructor, which is required for persisting them (see
   // _selected_package_ref() implementation for details).
   //
   using package_prerequisites = std::map<lazy_shared_ptr<selected_package>,
-                                         optional<version_constraint>,
+                                         prerequisite_info,
                                          compare_lazy_ptr>;
 
   // Database mapping for lazy_shared_ptr<selected_package> to configuration
@@ -1476,6 +1528,21 @@ namespace bpkg
     #pragma db column("pp.package")
     package_name name;
 
+    #pragma db transient
+    pair<size_t, size_t> config_position;
+
+    #pragma db member(config_dependency_index) \
+      column("pp.config_dependency_index")     \
+      virtual(size_t)                          \
+      access(config_position.first)            \
+      default(0)
+
+    #pragma db member(config_alternative_index) \
+      column("pp.config_alternative_index")     \
+      virtual(size_t)                           \
+      access(config_position.second)            \
+      default(0)
+
     #pragma db column("pp.")
     optional<version_constraint> constraint;
   };
@@ -1501,34 +1568,50 @@ namespace bpkg
   // not detached during such map lifetimes. Considers both package name and
   // database for objects comparison.
   //
-  struct config_package
+  struct package_key
   {
-    database&    db;
-    package_name name;
+    reference_wrapper<database> db;
+    package_name                name;
 
-    config_package (database& d, package_name n): db (d), name (move (n)) {}
+    package_key (database& d, package_name n): db (d), name (move (n)) {}
 
     // Create a pseudo-package (command line as a dependent, etc).
     //
-    config_package (database& d, string n)
+    package_key (database& d, string n)
         : db (d),
           name (n.empty () ? package_name () : package_name (move (n))) {}
 
     bool
-    operator== (const config_package& v) const
+    operator== (const package_key& v) const
     {
       // See operator==(database, database).
       //
-      return name == v.name && &db == &v.db;
+      return name == v.name && &db.get () == &v.db.get ();
     }
 
     bool
-    operator< (const config_package&) const;
+    operator!= (const package_key& v) const
+    {
+      return !(*this == v);
+    }
 
+    bool
+    operator< (const package_key&) const;
+
+    // Return the package string representation in the form:
+    //
+    // <name>[ <config-dir>]
+    //
     std::string
     string () const;
   };
 
+  inline ostream&
+  operator<< (ostream& os, const package_key& p)
+  {
+    return os << p.string ();
+  }
+
   // Return a count of repositories that contain this repository fragment.
   //
   #pragma db view table("main.repository_fragments")
diff --git a/bpkg/package.xml b/bpkg/package.xml
index 904d0f6..8959529 100644
--- a/bpkg/package.xml
+++ b/bpkg/package.xml
@@ -1,4 +1,11 @@
 <changelog xmlns="http://www.codesynthesis.com/xmlns/odb/changelog" database="sqlite" version="1">
+  <changeset version="19">
+    <alter-table name="main.selected_package_prerequisites">
+      <add-column name="config_dependency_index" type="INTEGER" null="true" default="0"/>
+      <add-column name="config_alternative_index" type="INTEGER" null="true" default="0"/>
+    </alter-table>
+  </changeset>
+
   <changeset version="18">
     <add-table name="main.selected_package_config_variables" kind="container">
       <column name="package" type="TEXT" null="true" options="COLLATE NOCASE"/>
diff --git a/bpkg/pkg-build.cli b/bpkg/pkg-build.cli
index b1415fe..493ffbe 100644
--- a/bpkg/pkg-build.cli
+++ b/bpkg/pkg-build.cli
@@ -379,11 +379,12 @@ namespace bpkg
     {
       "<sum>",
 
-      "Hash the names and versions of all the packages that would be built.
-       If the resulting checksum matches the specified, then exit without
-       building anything (potentially with a special error code specified
-       with the \cb{--noop-exit} option). Otherwise, proceed to build as
-       normal. In both cases, print the resulting checksum to \cb{stdout}."
+      "Hash the names, versions, and configurations of all the packages that
+       would be built. If the resulting checksum matches the specified, then
+       exit without building anything (potentially with a special error code
+       specified with the \cb{--noop-exit} option). Otherwise, proceed to
+       build as normal. In both cases, print the resulting checksum to
+       \cb{stdout}."
     }
 
     uint16_t --no-private-config
diff --git a/bpkg/pkg-build.cxx b/bpkg/pkg-build.cxx
index 6d90ff9..331ab9d 100644
--- a/bpkg/pkg-build.cxx
+++ b/bpkg/pkg-build.cxx
@@ -6,10 +6,13 @@
 #include <map>
 #include <set>
 #include <list>
-#include <cstring>    // strlen()
-#include <iostream>   // cout
+#include <limits>       // numeric_limits
+#include <cstring>      // strlen()
+#include <sstream>
+#include <iostream>     // cout
+#include <functional>   // ref()
+#include <forward_list>
 
-#include <libbutl/sha256.hxx>
 #include <libbutl/standard-version.hxx>
 
 #include <bpkg/package.hxx>
@@ -34,6 +37,7 @@
 #include <bpkg/pkg-disfigure.hxx>
 #include <bpkg/package-skeleton.hxx>
 #include <bpkg/system-repository.hxx>
+#include <bpkg/package-configuration.hxx>
 
 using namespace std;
 using namespace butl;
@@ -434,6 +438,55 @@ namespace bpkg
     return make_pair (move (ap), move (rf));
   }
 
+  // Try to find an available package corresponding to the specified selected
+  // package and, if not found, return a transient one.
+  //
+  static shared_ptr<available_package>
+  find_available (const common_options& options,
+                  database& db,
+                  const shared_ptr<selected_package>& sp)
+  {
+    available_package_id pid (sp->name, sp->version);
+    for (database& ddb: dependent_repo_configs (db))
+    {
+      shared_ptr<available_package> ap (ddb.find<available_package> (pid));
+
+      if (ap != nullptr && !ap->stub ())
+        return ap;
+    }
+
+    return make_available (options, db, sp);
+  }
+
+  // As above but also pair the available package with the repository fragment
+  // the available package comes from. Note that the package locations list is
+  // left empty and that the returned repository fragment could be NULL if the
+  // package is an orphan.
+  //
+  static pair<shared_ptr<available_package>,
+              lazy_shared_ptr<repository_fragment>>
+  find_available_fragment (const common_options& options,
+                           database& db,
+                           const shared_ptr<selected_package>& sp)
+  {
+    available_package_id pid (sp->name, sp->version);
+    for (database& ddb: dependent_repo_configs (db))
+    {
+      shared_ptr<available_package> ap (ddb.find<available_package> (pid));
+
+      if (ap != nullptr && !ap->stub ())
+      {
+        if (shared_ptr<repository_fragment> f = ddb.find<repository_fragment> (
+              sp->repository_fragment.canonical_name ()))
+          return make_pair (ap,
+                            lazy_shared_ptr<repository_fragment> (ddb,
+                                                                  move (f)));
+      }
+    }
+
+    return make_pair (find_available (options, db, sp), nullptr);
+  }
+
   // Return true if the version constraint represents the wildcard version.
   //
   static inline bool
@@ -453,7 +506,7 @@ namespace bpkg
   // prerequisites being replaced ("old"). The unamended prerequisites have no
   // entries.
   //
-  using repointed_dependents = map<config_package, map<config_package, bool>>;
+  using repointed_dependents = map<package_key, map<package_key, bool>>;
 
   // List of the private configuration paths, relative to the containing
   // configuration directories (.bpkg/host/, etc), together with the
@@ -480,10 +533,12 @@ namespace bpkg
   // any version constraints. Specifically, during this step, we may
   // "upgrade" or "downgrade" a package that is already in a map as a
   // result of another package depending on it and, for example, requiring
-  // a different version. One notable side-effect of this process is that
-  // we may end up with a lot more packages in the map (but not in the list)
-  // than we will have on the list. This is because some of the prerequisites
-  // of "upgraded" or "downgraded" packages may no longer need to be built.
+  // a different version. If that happens, we make sure that the replaced
+  // package version doesn't apply constraints and/or configuration to its
+  // own dependencies anymore and also that its non-shared dependencies are
+  // gone from the map, recursively (see replaced_versions for details).
+  // One notable side-effect of this process is that all the packages in the
+  // map end up in the list.
   //
   // Note that we don't try to do exhaustive constraint satisfaction (i.e.,
   // there is no backtracking). Specifically, if we have two candidate
@@ -557,10 +612,15 @@ namespace bpkg
     //
     // Initially nullopt. Can be filled partially if the package prerequisite
     // builds collection is postponed for any reason (see postponed_packages
-    // for possible reasons).
+    // and postponed_configurations for possible reasons).
     //
     optional<bpkg::dependencies> dependencies;
 
+    // Indexes of the selected dependency alternatives stored in the above
+    // dependencies member.
+    //
+    optional<vector<size_t>> alternatives;
+
     // If we end up collecting the prerequisite builds for this package, then
     // this member stores the skeleton of the package being built.
     //
@@ -573,15 +633,36 @@ namespace bpkg
 
     // If the package prerequisite builds collection is postponed, then this
     // member stores the references to the enabled alternatives (in available
-    // package) of a dependency being the cause of the postponement. This, in
-    // particular, allows not to re-evaluate conditions multiple times on the
-    // re-collection attempts.
+    // package) of a dependency being the cause of the postponement together
+    // with their original indexes in the respective dependency alternatives
+    // list. This, in particular, allows us not to re-evaluate conditions
+    // multiple times on the re-collection attempts.
     //
     // Note: it shouldn't be very common for a dependency to contain more than
     // two true alternatives.
     //
-    optional<small_vector<reference_wrapper<const dependency_alternative>, 2>>
-    postponed_dependency_alternatives;
+    using dependency_alternatives_refs =
+      small_vector<pair<reference_wrapper<const dependency_alternative>,
+                        size_t>,
+                   2>;
+
+    optional<dependency_alternatives_refs> postponed_dependency_alternatives;
+
+    // True if the recursive collection of the package has been started or
+    // performed.
+    //
+    // Used by the dependency configuration negotiation machinery which makes
+    // sure that its configuration is negotiated between dependents before its
+    // recursive collection is started (see postponed_configurations for
+    // details).
+    //
+    // Note that the dependencies member cannot be used for that purpose since
+    // it is not always created (think of a system dependency or an existing
+    // dependency that doesn't need its prerequisites re-collection). In a
+    // sense the recursive collection flag is a barrier for the dependency
+    // configuration negotiation.
+    //
+    bool recursive_collection;
 
     // Hold flags. Note that we only "increase" the hold_package value that is
     // already in the selected package.
@@ -645,7 +726,7 @@ namespace bpkg
     // selection and can be present regardless of the required_by_dependents
     // flag value.
     //
-    set<config_package> required_by;
+    set<package_key> required_by;
 
     // If this flags is true, then required_by contains dependents.
     //
@@ -659,8 +740,38 @@ namespace bpkg
     bool
     user_selection () const
     {
-      return required_by.find (config_package {db.get ().main_database (),
-                                               ""}) != required_by.end ();
+      return required_by.find (package_key {db.get ().main_database (),
+                                            ""}) != required_by.end ();
+    }
+
+    // Return true if the configured package needs to be recollected
+    // recursively.
+    //
+    // This is required if it is being built as a source package and needs to
+    // be up/down-graded and/or reconfigured and has some buildfile clauses,
+    // it is a repointed dependent, or it is already in the process of being
+    // collected.
+    //
+    bool
+    recollect_recursively (const repointed_dependents& rpt_depts) const
+    {
+      assert (action                                       &&
+              *action == build_package::build              &&
+              available != nullptr                         &&
+              selected != nullptr                          &&
+              selected->state == package_state::configured &&
+              selected->substate != package_substate::system);
+
+      // Note that if the skeleton is present then the package is either being
+      // already collected or its configuration has been negotiated between
+      // the dependents.
+      //
+      return !system &&
+             (dependencies                                     ||
+              selected->version != available_version ()        ||
+              ((!config_vars.empty () || skeleton) &&
+               has_buildfile_clause (available->dependencies)) ||
+              rpt_depts.find (package_key (db, name ())) != rpt_depts.end ());
     }
 
     // State flags.
@@ -882,7 +993,8 @@ namespace bpkg
         // dependency alternative choice.
         //
         assert (!skeleton ||
-                (p.config_vars == config_vars && p.disfigure == disfigure));
+                ((p.config_vars.empty () || p.config_vars == config_vars) &&
+                 p.disfigure == disfigure));
 
         if (p.keep_out)
           keep_out = p.keep_out;
@@ -945,6 +1057,57 @@ namespace bpkg
       // For other cases ("weak system") we don't want to copy system over in
       // order not prevent, for example, system to non-system upgrade.
     }
+
+    // Initialize the skeleton of a being built package.
+    //
+    package_skeleton&
+    init_skeleton (const common_options& options,
+                   const shared_ptr<available_package>& override = nullptr)
+    {
+      shared_ptr<available_package> ap (override != nullptr
+                                        ? override
+                                        : available);
+
+      assert (!skeleton && ap != nullptr);
+
+      package_key pk (db, ap->id.name);
+
+      if (system)
+      {
+        // Keep the available package if its version is "close enough" to the
+        // system package version. For now we will require the exact match
+        // but in the future we could relax this (e.g., allow the user to
+        // specify something like libfoo/^1.2.0 or some such).
+        //
+        const version* v (!ap->stub () ? ap->system_version (db) : nullptr);
+
+        if (v == nullptr || *v != ap->version)
+          ap = nullptr;
+      }
+
+      optional<dir_path> src_root, out_root;
+
+      if (ap != nullptr)
+      {
+        src_root = external_dir ();
+        out_root = (src_root && !disfigure
+                    ? dir_path (db.get ().config) /= name ().string ()
+                    : optional<dir_path> ());
+      }
+
+      skeleton = package_skeleton (
+        options,
+        move (pk),
+        system,
+        move (ap),
+        config_vars, // @@ Maybe make optional<strings> and move?
+        disfigure,
+        (selected != nullptr ? &selected->config_variables : nullptr),
+        move (src_root),
+        move (out_root));
+
+      return *skeleton;
+    }
   };
 
   using build_package_list = list<reference_wrapper<build_package>>;
@@ -954,24 +1117,1205 @@ namespace bpkg
 
   using add_priv_cfg_function = void (database&, dir_path&&);
 
-  struct build_packages: build_package_list
+  // Base for exception types that indicate an inability to collect a package
+  // build because it was collected prematurely (version needs to be replaced,
+  // configuration requires further negotiation, etc).
+  //
+  struct scratch_collection
+  {
+    // Only used for tracing.
+    //
+    const char* description;
+    const package_key* package = nullptr; // Could be NULL.
+
+    explicit
+    scratch_collection (const char* d): description (d) {}
+  };
+
+  // Map of packages which need to be re-collected with the different version
+  // and/or system flag or dropped.
+  //
+  // Note that the initial package version may be adjusted to satisfy
+  // constraints of dependents discovered during the packages collection. It
+  // may also be dropped if this is a dependency which turns out to be unused.
+  // However, it may not always be possible to perform such an adjustment
+  // in-place since the intermediate package version could already apply some
+  // constraints and/or configuration to its own dependencies. Thus, we may
+  // need to note the desired package version information and re-collect from
+  // scratch.
+  //
+  // Also note that during re-collection such a desired version may turn out
+  // to not be a final version and the adjustment/re-collection can repeat.
+  //
+  // And yet, it doesn't seem plausible to ever create a replacement for the
+  // drop: replacing one drop with another is meaningless (all drops are the
+  // same) and replacing the package drop with a package version build can
+  // always been handled in-place.
+  //
+  // On the first glance, the map entries which have not been used for
+  // replacement during the package collection (bogus entries) are harmless
+  // and can be ignored. However, the dependency configuration negotiation
+  // machinery refers to this map and skips existing dependents with
+  // configuration clause which belong to it (see query_existing_dependents()
+  // for details). Thus, if after collection of packages some bogus entries
+  // are present in the map, then it means that we could have erroneously
+  // skipped some existing dependents because of them and so need to erase
+  // these entries and re-collect.
+  //
+  struct replaced_version
+  {
+    // Desired package version, repository fragment, and system flag.
+    //
+    // Both are NULL for the replacement with the drop.
+    //
+    shared_ptr<available_package> available;
+    lazy_shared_ptr<bpkg::repository_fragment> repository_fragment;
+    bool system; // Meaningless for the drop.
+
+    // True if the entry has been inserted or used for the replacement during
+    // the current (re-)collection iteration. Used to keep track of "bogus"
+    // (no longer relevant) entries.
+    //
+    bool replaced;
+
+    // Create replacement with the different version.
+    //
+    replaced_version (shared_ptr<available_package> a,
+                      lazy_shared_ptr<bpkg::repository_fragment> f,
+                      bool s)
+        : available (move (a)),
+          repository_fragment (move (f)),
+          system (s),
+          replaced (true) {}
+
+    // Create replacement with the drop.
+    //
+    replaced_version (): system (false), replaced (true) {}
+  };
+
+  class replaced_versions: public map<package_key, replaced_version>
+  {
+  public:
+    // Erase the bogus replacements and, if any, throw cancel_replacement, if
+    // requested.
+    //
+    struct cancel_replacement: scratch_collection
+    {
+      cancel_replacement ()
+          : scratch_collection ("bogus version replacement cancellation") {}
+    };
+
+    void
+    cancel_bogus (tracer& trace, bool scratch)
+    {
+      bool bogus (false);
+      for (auto i (begin ()); i != end (); )
+      {
+        const replaced_version& v (i->second);
+
+        if (!v.replaced)
+        {
+          bogus = true;
+
+          l5 ([&]{trace << "erase bogus version replacement "
+                        << i->first;});
+
+          i = erase (i);
+        }
+        else
+          ++i;
+      }
+
+      if (bogus && scratch)
+      {
+        l5 ([&]{trace << "bogus version replacement erased, throwing";});
+        throw cancel_replacement ();
+      }
+    }
+  };
+
+  // List of dependency groups whose recursive processing should be postponed
+  // due to dependents with configuration clauses, together with these
+  // dependents (we will call them package clusters).
+  //
+  // The idea is that configuration for the dependencies in the cluster needs
+  // to be negotiated between the dependents in the cluster. Note that at any
+  // given time during collection a dependency can only belong to a single
+  // cluster. For example, the following dependent/dependencies with
+  // configuration clauses:
+  //
+  // foo: depends: libfoo
+  // bar: depends: libfoo
+  //      depends: libbar
+  // baz: depends: libbaz
+  //
+  // End up in the following clusters (see string() below for the cluster
+  // representation):
+  //
+  // {foo bar | libfoo->{foo/1,1 bar/1,1}}
+  // {bar     | libbar->{bar/2,1}}
+  // {baz     | libbaz->{baz/1,1}}
+  //
+  // Or, another example:
+  //
+  // foo: depends: libfoo
+  // bar: depends: libfoo libbar
+  // baz: depends: libbaz
+  //
+  // {foo bar | libfoo->{foo/1,1 bar/1,1} libbar->{bar/1,1}}
+  // {baz     | libbaz->{baz/1,1}}
+  //
+  // Note that a dependent can belong to any given non-negotiated cluster with
+  // only one `depends` position. However, if some dependency configuration is
+  // up-negotiated for a dependent, then multiple `depends` positions will
+  // correspond to this dependent in the same cluster. Naturally, such
+  // clusters are always (being) negotiated.
+  //
+  // Note that adding new dependent/dependencies to the postponed
+  // configurations can result in merging some of the existing clusters if the
+  // dependencies being added intersect with multiple clusters. For example,
+  // adding:
+  //
+  // fox: depends: libbar libbaz
+  //
+  // to the clusters in the second example will merge them into a single
+  // cluster:
+  //
+  // {foo bar baz fox | libfoo->{foo/1,1 bar/1,1} libbar->{bar/1,1 fox/1,1}
+  //                    libbaz->{baz/1,1 fox/1,1}}
+  //
+  // Also note that we keep track of packages which turn out to be
+  // dependencies of existing (configured) dependents with configuration
+  // clauses. The recursive processing of such packages should be postponed
+  // until negotiation between all the existing and new dependents which may
+  // or may not be present.
+  //
+  class postponed_configuration;
+
+  static ostream&
+  operator<< (ostream&, const postponed_configuration&);
+
+  class postponed_configuration
+  {
+  public:
+    // The id of the cluster plus the ids of all the clusters that have been
+    // merged into it.
+    //
+    size_t id;
+    small_vector<size_t, 1> merged_ids;
+
+    using packages = small_vector<package_key, 1>;
+
+    class dependency: public packages
+    {
+    public:
+      pair<size_t, size_t> position; // depends + alternative
+
+      dependency (const pair<size_t, size_t>& pos, packages deps)
+          : packages (move (deps)), position (pos) {}
+    };
+
+    class dependent_info
+    {
+    public:
+      bool existing;
+      small_vector<dependency, 1> dependencies;
+
+      dependency*
+      find_dependency (pair<size_t, size_t> pos)
+      {
+        auto i (find_if (dependencies.begin (),
+                         dependencies.end (),
+                         [&pos] (const dependency& d)
+                         {
+                           return d.position == pos;
+                         }));
+        return i != dependencies.end () ? &*i : nullptr;
+      }
+
+      void
+      add (dependency&& dep)
+      {
+        if (dependency* d = find_dependency (dep.position))
+        {
+          // Feels like we can accumulate dependencies into an existing
+          // position only for an existing dependent.
+          //
+          assert (existing);
+
+          for (package_key& p: dep)
+          {
+            // Add the dependency unless it's already there.
+            //
+            if (find (d->begin (), d->end (), p) == d->end ())
+              d->push_back (move (p));
+          }
+        }
+        else
+          dependencies.push_back (move (dep));
+      }
+    };
+
+    using dependents_map = map<package_key, dependent_info>;
+
+    dependents_map dependents;
+    packages       dependencies;
+
+    // Dependency configuration.
+    //
+    // Note that this container may not yet contain some entries that are
+    // already in the dependencies member above. And it may already contain
+    // entries that are not yet in dependencies due to the retry_configuration
+    // logic.
+    //
+    package_configurations dependency_configurations;
+
+    // Shadow clusters.
+    //
+    // See the collect lambda in collect_build_prerequisites() for details.
+    //
+    using positions = small_vector<pair<size_t, size_t>, 1>;
+    using shadow_dependents_map = map<package_key, positions>;
+
+    shadow_dependents_map shadow_cluster;
+
+    // Absent -- not negotiated yet, false -- being negotiated, true -- has
+    // been negotiated.
+    //
+    optional<bool> negotiated;
+
+    // The depth of the negotiating recursion (see collect_build_postponed()
+    // for details).
+    //
+    size_t depth = 0;
+
+    // Add dependencies of a new dependent.
+    //
+    postponed_configuration (size_t i,
+                             package_key&& dependent,
+                             bool existing,
+                             pair<size_t, size_t> position,
+                             packages&& deps)
+        : id (i)
+    {
+      add (move (dependent), existing, position, move (deps));
+    }
+
+    // Add dependency of an existing dependent.
+    //
+    postponed_configuration (size_t i,
+                             package_key&& dependent,
+                             pair<size_t, size_t> position,
+                             package_key&& dep)
+        : id (i)
+    {
+      add (move (dependent),
+           true /* existing */,
+           position,
+           packages ({move (dep)}));
+    }
+
+    // Add dependencies of a dependent.
+    //
+    // Note: adds the specified dependencies to the end of the configuration
+    // dependencies list suppressing duplicates.
+    //
+    void
+    add (package_key&& dependent,
+         bool existing,
+         pair<size_t, size_t> position,
+         packages&& deps)
+    {
+      assert (position.first != 0 && position.second != 0);
+
+      add_dependencies (deps); // Don't move from since will be used later.
+
+      auto i (dependents.find (dependent));
+
+      if (i != dependents.end ())
+      {
+        dependent_info& ddi (i->second);
+
+        ddi.add (dependency (position, move (deps)));
+
+        // Conceptually, on the first glance, we can only move from existing
+        // to non-existing (e.g., due to a upgrade/downgrade later) and that
+        // case is handled via the version replacement rollback. However,
+        // after re-evaluation the existing dependent is handled similar to
+        // the new dependent and we can potentially up-negotiate the
+        // dependency configuration for it.
+        //
+        assert (ddi.existing || !existing);
+      }
+      else
+      {
+        small_vector<dependency, 1> ds ({dependency (position, move (deps))});
+
+        dependents.emplace (move (dependent),
+                            dependent_info {existing, move (ds)});
+      }
+    }
+
+    // Return true if any of the configuration's dependents depend on the
+    // specified package.
+    //
+    bool
+    contains_dependency (const package_key& d) const
+    {
+      return find (dependencies.begin (), dependencies.end (), d) !=
+             dependencies.end ();
+    }
+
+    // Return true if this configuration contains any of the specified
+    // dependencies.
+    //
+    bool
+    contains_dependency (const packages& ds) const
+    {
+      for (const package_key& d: ds)
+      {
+        if (contains_dependency (d))
+          return true;
+      }
+
+      return false;
+    }
+
+    // Return true if this and specified configurations contain any common
+    // dependencies.
+    //
+    bool
+    contains_dependency (const postponed_configuration& c) const
+    {
+      for (const auto& d: c.dependencies)
+      {
+        if (contains_dependency (d))
+          return true;
+      }
+
+      return false;
+    }
+
+    // If the configuration contains the specified existing dependent, then
+    // return the earliest dependency position. Otherwise return NULL.
+    //
+    const pair<size_t, size_t>*
+    existing_dependent_position (const package_key& p) const
+    {
+      const pair<size_t, size_t>* r (nullptr);
+
+      auto i (dependents.find (p));
+      if (i != dependents.end () && i->second.existing)
+      {
+        for (const dependency& d: i->second.dependencies)
+        {
+          if (r == nullptr || d.position < *r)
+            r = &d.position;
+        }
+
+        assert (r != nullptr);
+      }
+
+      return r;
+    }
+
+    // Notes:
+    //
+    // - Adds dependencies of the being merged from configuration to the end
+    //   of the current configuration dependencies list suppressing
+    //   duplicates.
+    //
+    // - Doesn't change the negotiate member of this configuration.
+    //
+    void
+    merge (postponed_configuration&& c)
+    {
+      assert (c.id != id); // Can't merge to itself.
+
+      merged_ids.push_back (c.id);
+
+      // Merge dependents.
+      //
+      for (auto& d: c.dependents)
+      {
+        auto i (dependents.find (d.first));
+
+        if (i != dependents.end ())
+        {
+          dependent_info& ddi (i->second); // Destination dependent info.
+          dependent_info& sdi (d.second);  // Source dependent info.
+
+          for (dependency& sd: sdi.dependencies)
+            ddi.add (move (sd));
+
+          // As in add() above.
+          //
+          assert (ddi.existing || !sdi.existing);
+        }
+        else
+          dependents.emplace (d.first, move (d.second));
+      }
+
+      // Merge dependencies.
+      //
+      add_dependencies (move (c.dependencies));
+
+      // Pick the depth of the outermost negotiated configuration (minimum
+      // non-zero depth) between the two.
+      //
+      if (depth != 0)
+      {
+        if (c.depth != 0 && depth > c.depth)
+          depth = c.depth;
+      }
+      else
+        depth = c.depth;
+    }
+
+    void
+    set_shadow_cluster (postponed_configuration&& c)
+    {
+      shadow_cluster.clear ();
+
+      for (auto& dt: c.dependents)
+      {
+        positions ps;
+        for (auto& d: dt.second.dependencies)
+          ps.push_back (d.position);
+
+        shadow_cluster.emplace (dt.first, move (ps));
+      }
+    }
+
+    bool
+    contains_in_shadow_cluster (package_key dependent,
+                                pair<size_t, size_t> pos) const
+    {
+      auto i (shadow_cluster.find (dependent));
+
+      if (i != shadow_cluster.end ())
+      {
+        const positions& ps (i->second);
+        return find (ps.begin (), ps.end (), pos) != ps.end ();
+      }
+      else
+        return false;
+    }
+
+    // Return the postponed configuration string representation in the form:
+    //
+    // {<dependent>[ <dependent>]* | <dependency>[ <dependency>]*}['!'|'?']
+    //
+    // <dependent>  = <package>['^']
+    // <dependency> = <package>->{<dependent>/<position>[ <dependent>/<position>]*}
+    //
+    // The potential trailing '!' or '?' of the configuration representation
+    // indicates that the configuration is negotiated or is being negotiated,
+    // respectively.
+    //
+    // '^' character that may follow a dependent indicates that this is an
+    // existing dependent.
+    //
+    // <position> = <depends-index>','<alternative-index>
+    //
+    // <depends-index> and <alternative-index> are the 1-based serial numbers
+    // of the respective depends value and the dependency alternative in the
+    // dependent's manifest.
+    //
+    // See package_key for details on <package>.
+    //
+    // For example:
+    //
+    // {foo^ bar | libfoo->{foo/2,3 bar/1,1} libbar->{bar/1,1}}!
+    //
+    std::string
+    string () const
+    {
+      std::string r;
+
+      for (const auto& d: dependents)
+      {
+        r += r.empty () ? '{' : ' ';
+        r += d.first.string ();
+
+        if (d.second.existing)
+          r += '^';
+      }
+
+      if (r.empty ())
+        r += '{';
+
+      r += " |";
+
+      for (const package_key& d: dependencies)
+      {
+        r += ' ';
+        r += d.string ();
+        r += "->{";
+
+        bool first (true);
+        for (const auto& dt: dependents)
+        {
+          for (const dependency& dp: dt.second.dependencies)
+          {
+            if (find (dp.begin (), dp.end (), d) != dp.end ())
+            {
+              if (!first)
+                r += ' ';
+              else
+                first = false;
+
+              r += dt.first.string ();
+              r += '/';
+              r += to_string (dp.position.first);
+              r += ',';
+              r += to_string (dp.position.second);
+            }
+          }
+        }
+
+        r += '}';
+      }
+
+      r += '}';
+
+      if (negotiated)
+        r += *negotiated ? '!' : '?';
+
+      return r;
+    }
+
+  private:
+    // Add the specified packages to the end of the dependencies list
+    // suppressing duplicates.
+    //
+    void
+    add_dependencies (packages&& deps)
+    {
+      for (auto& d: deps)
+      {
+        if (find (dependencies.begin (), dependencies.end (), d) ==
+            dependencies.end ())
+          dependencies.push_back (move (d));
+      }
+    }
+
+    void
+    add_dependencies (const packages& deps)
+    {
+      for (const auto& d: deps)
+      {
+        if (find (dependencies.begin (), dependencies.end (), d) ==
+            dependencies.end ())
+          dependencies.push_back (d);
+      }
+    }
+  };
+
+  static ostream&
+  operator<< (ostream& os, const postponed_configuration& c)
+  {
+    return os << c.string ();
+  }
+
+  // Note that we could be adding new/merging existing entries while
+  // processing an entry. Thus we use a list.
+  //
+  class postponed_configurations: public forward_list<postponed_configuration>
+  {
+  public:
+    // Return the configuration the dependent is added to (after all the
+    // potential configuration merges, etc).
+    //
+    // Also return in second absent if the merge happened due to the shadow
+    // cluster logic (in which case the cluster was/is being negotiated),
+    // false if any non-negotiated or being negotiated clusters has been
+    // merged in, and true otherwise.
+    //
+    // If some configurations needs to be merged and this involves the (being)
+    // negotiated configurations, then merge into the outermost-depth
+    // negotiated configuration (with minimum non-zero depth).
+    //
+    pair<postponed_configuration&, optional<bool>>
+    add (package_key dependent,
+         bool existing,
+         pair<size_t, size_t> position,
+         postponed_configuration::packages dependencies)
+    {
+      tracer trace ("postponed_configurations::add");
+
+      assert (!dependencies.empty ());
+
+      // The plan is to first go through the existing clusters and check if
+      // any of them contain this dependent/dependencies in their shadow
+      // clusters. If such a cluster is found, then force-add them to
+      // it. Otherwise, if any dependency-intersecting clusters are present,
+      // then add the specified dependent/dependencies to the one with the
+      // minimum non-zero depth, if any, and to the first one otherwise.
+      // Otherwise, add the new cluster. Afterwards, merge into the resulting
+      // cluster other dependency-intersecting clusters. Note that in case of
+      // shadow, this should normally not happen because such a cluster should
+      // have been either pre-merged or its dependents should be in the
+      // cluster. But it feels like it may still happen if things change, in
+      // which case we will throw again (admittedly a bit fuzzy).
+      //
+      iterator ri;
+      bool rb (true);
+
+      // Note that if a single dependency is added, then it can only belong to
+      // a single existing cluster and so no clusters merge can happen, unless
+      // we are force-adding. In the later case we can only merge once for a
+      // single dependency.
+      //
+      // Let's optimize for the common case based on these facts.
+      //
+      bool single (dependencies.size () == 1);
+
+      // Merge dependency-intersecting clusters in the specified range into
+      // the resulting cluster and reset change rb to false if any of the
+      // merged in clusters is non-negotiated or is being negotiated.
+      //
+      // The iterator arguments refer to entries before and after the range
+      // endpoints, respectively.
+      //
+      auto merge = [&trace, &ri, &rb, single, this] (iterator i,
+                                                     iterator e,
+                                                     bool shadow_based)
+      {
+        postponed_configuration& rc (*ri);
+
+        iterator j (i);
+
+        // Merge the intersecting configurations.
+        //
+        bool merged (false);
+        for (++i; i != e; ++i)
+        {
+          postponed_configuration& c (*i);
+
+          if (c.contains_dependency (rc))
+          {
+            if (!c.negotiated || !*c.negotiated)
+              rb = false;
+
+            l5 ([&]{trace << "merge " << c << " into " << rc;});
+
+            assert (!shadow_based || (c.negotiated && *c.negotiated));
+
+            rc.merge (move (c));
+            c.dependencies.clear (); // Mark as merged from (see above).
+
+            merged = true;
+
+            if (single)
+              break;
+          }
+        }
+
+        // Erase configurations which we have merged from.
+        //
+        if (merged)
+        {
+          i = j;
+
+          for (++i; i != e; )
+          {
+            if (!i->dependencies.empty ())
+            {
+              ++i;
+              ++j;
+            }
+            else
+              i = erase_after (j);
+          }
+        }
+      };
+
+      auto trace_add = [&trace, &dependent, existing, position, &dependencies]
+                       (const postponed_configuration& c, bool shadow)
+      {
+        if (verb >= 5)
+        {
+          diag_record dr (trace);
+          dr << "add {" << dependent;
+
+          if (existing)
+            dr << '^';
+
+          dr << ' ' << position.first << ',' << position.second << ':';
+
+          for (const auto& d: dependencies)
+            dr << ' ' << d;
+
+          dr << "} to " << c;
+
+          if (shadow)
+            dr << " (shadow cluster-based)";
+        }
+      };
+
+      // Try to add based on the shadow cluster.
+      //
+      {
+        auto i (begin ());
+        for (; i != end (); ++i)
+        {
+          postponed_configuration& c (*i);
+
+          if (c.contains_in_shadow_cluster (dependent, position))
+          {
+            trace_add (c, true /* shadow */);
+
+            c.add (move (dependent), existing, position, move (dependencies));
+            break;
+          }
+        }
+
+        if (i != end ())
+        {
+          // Note that the cluster with a shadow cluster is by definition
+          // either being negotiated or has been negotiated. Actually, there
+          // is also a special case when we didn't negotiate the configuration
+          // yet and are in the process of re-evaluating existing dependents.
+          // Note though, that in this case we have already got the try/catch
+          // frame corresponding to the cluster negotiation (see
+          // collect_build_postponed() for details).
+          //
+          assert (i->depth != 0);
+
+          ri = i;
+
+          merge (before_begin (), ri, true /* shadow_based */);
+          merge (ri, end (), true /* shadow_based */);
+
+          return make_pair (ref (*ri), optional<bool> ());
+        }
+      }
+
+      // Find the cluster to add the dependent/dependencies to.
+      //
+      optional<size_t> depth;
+
+      auto j (before_begin ()); // Precedes iterator i.
+      for (auto i (begin ()); i != end (); ++i, ++j)
+      {
+        postponed_configuration& c (*i);
+
+        if (c.contains_dependency (dependencies) &&
+            (!depth || (c.depth != 0 && (*depth == 0 || *depth > c.depth))))
+        {
+          ri = i;
+          depth = c.depth;
+        }
+      }
+
+      if (!depth) // No intersecting cluster?
+      {
+        // New cluster. Insert after the last element.
+        //
+        ri = insert_after (j,
+                           postponed_configuration (
+                             next_id_++,
+                             move (dependent),
+                             existing,
+                             position,
+                             move (dependencies)));
+
+        l5 ([&]{trace << "create " << *ri;});
+      }
+      else
+      {
+        // Add the dependent/dependencies into an existing cluster.
+        //
+        postponed_configuration& c (*ri);
+
+        trace_add (c, false /* shadow */);
+
+        c.add (move (dependent), existing, position, move (dependencies));
+
+        // Try to merge other clusters into this cluster.
+        //
+        merge (before_begin (), ri, false /* shadow_based */);
+        merge (ri, end (), false /* shadow_based */);
+      }
+
+      return make_pair (ref (*ri), optional<bool> (rb));
+    }
+
+    // Add new postponed configuration cluster with a single dependency of an
+    // existing dependent.
+    //
+    // Note that it's the caller's responsibility to make sure that the
+    // dependency doesn't already belong to any existing cluster.
+    //
+    void
+    add (package_key dependent,
+         pair<size_t, size_t> position,
+         package_key dependency)
+    {
+      tracer trace ("postponed_configurations::add");
+
+      // Add the new cluster to the end of the list which we can only find by
+      // traversing the list. While at it, make sure that the dependency
+      // doesn't belong to any existing cluster.
+      //
+      auto i (before_begin ()); // Insert after this element.
+
+      for (auto j (begin ()); j != end (); ++i, ++j)
+        assert (!j->contains_dependency (dependency));
+
+      i = insert_after (i,
+                        postponed_configuration (next_id_++,
+                                                 move (dependent),
+                                                 position,
+                                                 move (dependency)));
+
+      l5 ([&]{trace << "create " << *i;});
+    }
+
+    postponed_configuration*
+    find (size_t id)
+    {
+      for (postponed_configuration& cfg: *this)
+      {
+        if (cfg.id == id)
+          return &cfg;
+      }
+
+      return nullptr;
+    }
+
+    // Return address of the cluster the dependency belongs to and NULL if it
+    // doesn't belong to any cluster.
+    //
+    const postponed_configuration*
+    find_dependency (const package_key& d) const
+    {
+      for (const postponed_configuration& cfg: *this)
+      {
+        if (cfg.contains_dependency (d))
+          return &cfg;
+      }
+
+      return nullptr;
+    }
+
+    // Return true if all the configurations have been negotiated.
+    //
+    bool
+    negotiated () const
+    {
+      for (const postponed_configuration& cfg: *this)
+      {
+        if (!cfg.negotiated || !*cfg.negotiated)
+          return false;
+      }
+
+      return true;
+    }
+
+    // Translate index to iterator and return the referenced configuration.
+    //
+    postponed_configuration&
+    operator[] (size_t index)
+    {
+      auto i (begin ());
+      for (size_t j (0); j != index; ++j, ++i) assert (i != end ());
+
+      assert (i != end ());
+      return *i;
+    }
+
+    size_t
+    size () const
+    {
+      size_t r (0);
+      for (auto i (begin ()); i != end (); ++i, ++r) ;
+      return r;
+    }
+
+  private:
+    size_t next_id_ = 1;
+  };
+
+  // The following exceptions are used by the dependency configuration
+  // up-negotiation/refinement machinery. See the collect lambda in
+  // collect_build_prerequisites() for details.
+  //
+  struct retry_configuration
+  {
+    size_t               depth;
+    package_key          dependent;
+  };
+
+  struct merge_configuration
+  {
+    size_t depth;
+  };
+
+  // Packages with postponed prerequisites collection, for one of the
+  // following reasons:
+  //
+  // - Postponed due to the inability to find a version satisfying the pre-
+  //   entered constraint from repositories available to this package. The
+  //   idea is that this constraint could still be satisfied from a repository
+  //   fragment of some other package (that we haven't processed yet) that
+  //   also depends on this prerequisite.
+  //
+  // - Postponed due to the inability to choose between two dependency
+  //   alternatives, both having dependency packages which are not yet
+  //   selected in the configuration nor being built. The idea is that this
+  //   ambiguity could still be resolved after some of those dependency
+  //   packages get built via some other dependents.
+  //
+  using postponed_packages = set<build_package*>;
+
+  // Map of dependency packages whose recursive processing should be postponed
+  // because they have dependents with configuration clauses.
+  //
+  // Note that dependents of such a package that don't have any configuration
+  // clauses are processed right away (since the negotiated configuration may
+  // not affect them) while those that do are postponed in the same way as
+  // those with dependency alternatives (see above).
+  //
+  // Note that the latter kind of dependent is what eventually causes
+  // recursive processing of the dependency packages. Which means we must
+  // watch out for bogus entries in this map which we may still end up with
+  // (e.g., because postponement caused cross-talk between dependency
+  // alternatives). Thus we keep flags that indicate whether we have seen each
+  // type of dependent and then just process dependencies that have the first
+  // (without config) but not the second (with config). We also need to track
+  // at which phase of collection an entry has been added to process the bogus
+  // entries accordingly.
+  //
+  struct postponed_dependency
+  {
+    bool wout_config; // Has dependent without config.
+    bool with_config; // Has dependent with config.
+    bool initial_collection;
+
+    postponed_dependency (bool woc, bool wic, bool ic)
+        : wout_config (woc),
+          with_config (wic),
+          initial_collection (ic) {}
+
+    bool
+    bogus () const {return wout_config && !with_config;}
+  };
+
+  class postponed_dependencies: public map<package_key, postponed_dependency>
+  {
+  public:
+    bool
+    has_bogus () const
+    {
+      for (const auto& pd: *this)
+      {
+        if (pd.second.bogus ())
+          return true;
+      }
+      return false;
+    }
+
+    // Erase the bogus postponements and throw cancel_postponement, if any.
+    //
+    struct cancel_postponement: scratch_collection
+    {
+      cancel_postponement ()
+          : scratch_collection (
+            "bogus dependency collection postponement cancellation") {}
+    };
+
+    void
+    cancel_bogus (tracer& trace, bool initial_collection)
+    {
+      bool bogus (false);
+      for (auto i (begin ()); i != end (); )
+      {
+        const postponed_dependency& d (i->second);
+
+        if (d.bogus () && (!initial_collection || d.initial_collection))
+        {
+          bogus = true;
+
+          l5 ([&]{trace << "erase bogus postponement " << i->first;});
+
+          i = erase (i);
+        }
+        else
+          ++i;
+      }
+
+      if (bogus)
+      {
+        l5 ([&]{trace << "bogus postponements erased, throwing";});
+        throw cancel_postponement ();
+      }
+    }
+  };
+
+  // Map of existing dependents which may not be re-evaluated to a position
+  // with the dependency index greater than the specified one.
+  //
+  // This mechanism applies when we re-evaluate an existing dependent to a
+  // certain position but later realize we've gone too far. In this case we
+  // note the earlier position information and re-collect from scratch. On the
+  // re-collection any re-evaluation of the dependent to a greater position
+  // will be either skipped or performed but to this earlier position (see the
+  // replace member for details).
+  //
+  // We consider the postponement bogus if some dependent re-evaluation was
+  // skipped due to its presence but no re-evaluation to this (or earlier)
+  // dependency index was performed. Thus, if after the collection of packages
+  // some bogus entries are present in the map, then it means that we have
+  // skipped the respective re-evaluations erroneously and so need to erase
+  // these entries and re-collect.
+  //
+  // Note that if no re-evaluation is skipped due to a postponement then it
+  // is harmless and we don't consider it bogus.
+  //
+  struct postponed_position: pair<size_t, size_t>
   {
-    // Packages with postponed prerequisites collection, for one of the
-    // following reasons:
+    // True if the "later" position should be replaced rather than merely
+    // skipped. The replacement deals with the case where the "earlier"
+    // position is encountered while processing the same cluster as what
+    // contains the later position. In this case, if we merely skip, then we
+    // will never naturally encounter the earlier position. So we have to
+    // force the issue (even if things change enough for us to never see the
+    // later position again).
     //
-    // - Postponed due to the inability to find a version satisfying the pre-
-    //   entered constraint from repositories available to this package. The
-    //   idea is that this constraint could still be satisfied from a
-    //   repository fragment of some other package (that we haven't processed
-    //   yet) that also depends on this prerequisite.
+    bool replace;
+
+    // Re-evaluation was skipped due to this postponement.
     //
-    // - Postponed due to the inability to choose between two dependency
-    //   alternatives, both having dependency packages which are not yet
-    //   selected in the configuration nor being built. The idea is that this
-    //   ambiguity could still be resolved after some of those dependency
-    //   packages get built via some other dependents.
+    bool skipped = false;
+
+    // The dependent was re-evaluated. Note that it can be only re-evaluated
+    // to this or earlier dependency index.
+    //
+    bool reevaluated = false;
+
+    postponed_position (pair<size_t, size_t> p, bool r)
+        : pair<size_t, size_t> (p), replace (r) {}
+  };
+
+  class postponed_positions: public map<package_key, postponed_position>
+  {
+  public:
+    // If true, override the first encountered non-replace position to replace
+    // and clear this flag. See collect_build_postponed() for details.
+    //
+    bool replace = false;
+
+    // Erase the bogus postponements and throw cancel_postponement, if any.
+    //
+    struct cancel_postponement: scratch_collection
+    {
+      cancel_postponement ()
+          : scratch_collection ("bogus existing dependent re-evaluation "
+                                "postponement cancellation") {}
+    };
+
+    void
+    cancel_bogus (tracer& trace)
+    {
+      bool bogus (false);
+      for (auto i (begin ()); i != end (); )
+      {
+        const postponed_position& p (i->second);
+
+        if (p.skipped && !p.reevaluated)
+        {
+          bogus = true;
+
+          l5 ([&]{trace << "erase bogus existing dependent " << i->first
+                        << " re-evaluation postponement with dependency index "
+                        << i->second.first;});
+
+          // It seems that the replacement may never be bogus.
+          //
+          assert (!p.replace);
+
+          i = erase (i);
+        }
+        else
+          ++i;
+      }
+
+      if (bogus)
+      {
+        l5 ([&]{trace << "bogus re-evaluation postponement erased, throwing";});
+        throw cancel_postponement ();
+      }
+    }
+  };
+
+  struct build_packages: build_package_list
+  {
+    build_packages () = default;
+
+    // Copy-constructible and move-assignable (used for snapshoting).
     //
-    using postponed_packages = set<build_package*>;
+    build_packages (const build_packages& v)
+        : build_package_list ()
+    {
+      // Copy the map.
+      //
+      for (const auto& p: v.map_)
+        map_.emplace (p.first, data_type {end (), p.second.package});
+
+      // Copy the list.
+      //
+      for (const auto& p: v)
+      {
+        auto i (map_.find (p.get ().db, p.get ().name ()));
+        assert (i != map_.end ());
+        i->second.position = insert (end (), i->second.package);
+      }
+    }
+
+    build_packages (build_packages&&) = delete;
+
+    build_packages& operator= (const build_packages&) = delete;
+
+    build_packages&
+    operator= (build_packages&& v)
+    {
+      clear ();
+
+      // Move the map.
+      //
+      // Similar to what we do in the copy-constructor, but here we also need
+      // to restore the database reference and the package shared pointers in
+      // the source entry after the move. This way we can obtain the source
+      // packages databases and names later while copying the list.
+      //
+      for (auto& p: v.map_)
+      {
+        build_package& bp (p.second.package);
+
+        database&                     db (bp.db);
+        shared_ptr<selected_package>  sp (bp.selected);
+        shared_ptr<available_package> ap (bp.available);
+
+        map_.emplace (p.first, data_type {end (), move (bp)});
+
+        bp.db        = db;
+        bp.selected  = move (sp);
+        bp.available = move (ap);
+      }
+
+      // Copy the list.
+      //
+      for (const auto& p: v)
+      {
+        auto i (map_.find (p.get ().db, p.get ().name ()));
+        assert (i != map_.end ());
+        i->second.position = insert (end (), i->second.package);
+      }
+
+      return *this;
+    }
 
     // Pre-enter a build_package without an action. No entry for this package
     // may already exists.
@@ -982,23 +2326,46 @@ namespace bpkg
       assert (!pkg.action);
 
       database& db (pkg.db); // Save before the move() call.
-      auto p (map_.emplace (config_package {db, move (name)},
+      auto p (map_.emplace (package_key {db, move (name)},
                             data_type {end (), move (pkg)}));
 
       assert (p.second);
     }
 
-    // Return true if a package is already in the map.
+    // Return the package pointer if it is already in the map and NULL
+    // otherwise (so can be used as bool).
     //
-    bool
-    entered (database& db, const package_name& name)
+    build_package*
+    entered_build (database& db, const package_name& name)
     {
-      return map_.find (db, name) != map_.end ();
+      auto i (map_.find (db, name));
+      return i != map_.end () ? &i->second.package : nullptr;
+    }
+
+    build_package*
+    entered_build (const package_key& p)
+    {
+      return entered_build (p.db, p.name);
     }
 
     // Collect the package being built. Return its pointer if this package
     // version was, in fact, added to the map and NULL if it was already there
-    // or the existing version was preferred. So can be used as bool.
+    // and the existing version was preferred or if the package build has been
+    // replaced with the drop. So can be used as bool.
+    //
+    // Consult replaced_vers for an existing version replacement entry and
+    // follow it, if present, potentially collecting the package drop
+    // instead. Add entry to replaced_vers and throw replace_version if the
+    // existing version needs to be replaced but the new version cannot be
+    // re-collected recursively in-place (see replaced_versions for details).
+    // Also add an entry and throw if the existing dependent needs to be
+    // replaced.
+    //
+    // Optionally, pass the function which verifies the chosen package
+    // version. It is called before replace_version is potentially thrown or
+    // the recursive collection is performed. The scratch argument is true if
+    // the package version needs to be replaced but in-place replacement is
+    // not possible (see replaced_versions for details).
     //
     // Also, in the recursive mode (dep_chain is not NULL):
     //
@@ -1015,54 +2382,132 @@ namespace bpkg
     // Note that postponed_* and dep_chain arguments must all be either
     // specified or not.
     //
+    struct replace_version: scratch_collection
+    {
+      replace_version ()
+          : scratch_collection ("package version replacement") {}
+    };
+
+    using verify_package_build_function = void (const build_package&,
+                                                bool scratch);
+
     build_package*
     collect_build (const pkg_build_options& options,
                    build_package pkg,
                    const function<find_database_function>& fdb,
                    const repointed_dependents& rpt_depts,
                    const function<add_priv_cfg_function>& apc,
+                   bool initial_collection,
+                   replaced_versions& replaced_vers,
+                   postponed_configurations& postponed_cfgs,
+                   build_package_refs* dep_chain = nullptr,
                    postponed_packages* postponed_repo = nullptr,
                    postponed_packages* postponed_alts = nullptr,
-                   build_package_refs* dep_chain = nullptr)
+                   postponed_dependencies* postponed_deps = nullptr,
+                   postponed_positions* postponed_poss = nullptr,
+                   const function<verify_package_build_function>& vpb = nullptr)
     {
       using std::swap; // ...and not list::swap().
 
       tracer trace ("collect_build");
 
-      // Must all be either specified or not.
+      // See the above notes.
       //
-      assert ((dep_chain == nullptr) == (postponed_repo == nullptr));
-      assert ((postponed_repo == nullptr) == (postponed_alts == nullptr));
+      bool recursive (dep_chain != nullptr);
+      assert ((postponed_repo != nullptr) == recursive &&
+              (postponed_alts != nullptr) == recursive &&
+              (postponed_deps != nullptr) == recursive &&
+              (postponed_poss != nullptr) == recursive);
 
       // Only builds are allowed here.
       //
       assert (pkg.action && *pkg.action == build_package::build &&
               pkg.available != nullptr);
 
-      auto i (map_.find (pkg.db, pkg.available->id.name));
+      package_key pk (pkg.db, pkg.available->id.name);
+
+      // Apply the version replacement, if requested, and indicate that it was
+      // applied.
+      //
+      auto vi (replaced_vers.find (pk));
+
+      if (vi != replaced_vers.end () && !vi->second.replaced)
+      {
+        l5 ([&]{trace << "apply version replacement for "
+                      << pkg.available_name_version_db ();});
+
+        replaced_version& v (vi->second);
+
+        v.replaced = true;
+
+        if (v.available != nullptr)
+        {
+          pkg.available = v.available;
+          pkg.repository_fragment = v.repository_fragment;
+          pkg.system = v.system;
+
+          l5 ([&]{trace << "replacement: "
+                        << pkg.available_name_version_db ();});
+        }
+        else
+        {
+          l5 ([&]{trace << "replacement: drop";});
+
+          assert (pkg.selected != nullptr);
 
-      // If we already have an entry for this package name, then we
-      // have to pick one over the other.
+          collect_drop (options, pkg.db, pkg.selected, replaced_vers);
+          return nullptr;
+        }
+      }
+
+      // Add the version replacement entry, call the verification function if
+      // specified, and throw replace_version.
       //
-      // If the existing entry is a pre-entered or is non-build one, then we
-      // merge it into the new build entry. Otherwise (both are builds), we
-      // pick one and merge the other into it.
+      auto replace_ver = [&pk, &vpb, &vi, &replaced_vers]
+                         (const build_package& p)
+      {
+        replaced_version rv (p.available, p.repository_fragment, p.system);
+
+        if (vi != replaced_vers.end ())
+          vi->second = move (rv);
+        else
+          replaced_vers.emplace (move (pk), move (rv));
+
+        if (vpb)
+          vpb (p, true /* scratch */);
+
+        throw replace_version ();
+      };
+
+      auto i (map_.find (pk));
+
+      // If we already have an entry for this package name, then we have to
+      // pick one over the other.
+      //
+      // If the existing entry is a drop, then we override it. If the existing
+      // entry is a pre-entered or is non-build one, then we merge it into the
+      // new build entry. Otherwise (both are builds), we pick one and merge
+      // the other into it.
       //
       if (i != map_.end ())
       {
         build_package& bp (i->second.package);
 
-        // Can't think of the scenario when this happens. We would start
-        // collecting from scratch (see below).
+        // Note that we used to think that the scenario when the build could
+        // replace drop could never happen since we would start collecting
+        // from scratch. This has changed when we introduced replaced_versions
+        // for collecting drops.
         //
-        assert (!bp.action || *bp.action != build_package::drop);
-
-        if (!bp.action || *bp.action != build_package::build) // Non-build.
+        if (bp.action && *bp.action == build_package::drop)        // Drop.
+        {
+          bp = move (pkg);
+        }
+        else if (!bp.action || *bp.action != build_package::build) // Non-build.
         {
           pkg.merge (move (bp));
           bp = move (pkg);
         }
-        else                                                  // Build.
+        else                                                       // Build.
         {
           // At the end we want p1 to point to the object that we keep
           // and p2 to the object that we merge from.
@@ -1140,10 +2585,9 @@ namespace bpkg
                           << " over " << p2->available_name_version_db ();});
           }
 
-          // See if we are replacing the object. If not, then we don't
-          // need to collect its prerequisites since that should have
-          // already been done. Remember, p1 points to the object we
-          // want to keep.
+          // See if we are replacing the object. If not, then we don't need to
+          // collect its prerequisites since that should have already been
+          // done. Remember, p1 points to the object we want to keep.
           //
           bool replace (p1 != &i->second.package);
 
@@ -1155,26 +2599,99 @@ namespace bpkg
 
           p1->merge (move (*p2));
 
-          if (!replace)
+          if (replace)
+          {
+            if (p1->available_version () != p2->available_version () ||
+                p1->system != p2->system)
+            {
+              // See if in-place replacement is possible (no dependencies,
+              // etc) and set scratch to false if that's the case.
+              //
+              // Firstly, such a package should not participate in any
+              // configuration negotiation.
+              //
+              // Other than that, it looks like the only optimization we can
+              // do easily is if the package has no dependencies (and thus
+              // cannot impose any constraints). Anything more advanced would
+              // require analyzing our dependencies (which we currently cannot
+              // easily get) and (1) either dropping the dependency
+              // build_package altogether if we are the only dependent (so
+              // that it doesn't influence any subsequent dependent) or (2)
+              // making sure our constraint is a sub-constraint of any other
+              // constraint and removing it from the dependency build_package.
+              // Maybe/later.
+              //
+              // NOTE: remember to update collect_drop() if changing anything
+              // here.
+              //
+              bool scratch (true);
+
+              // While checking if the package has any dependencies skip the
+              // toolchain build-time dependencies since they should be quite
+              // common.
+              //
+              if (!has_dependencies (options, p2->available->dependencies))
+                scratch = false;
+
+              l5 ([&]{trace << p2->available_name_version_db ()
+                            << " package version needs to be replaced "
+                            << (!scratch ? "in-place " : "") << "with "
+                            << p1->available_name_version_db ();});
+
+              if (scratch)
+                replace_ver (*p1);
+            }
+            else
+            {
+              // It doesn't seem possible that replacing the build object
+              // without changing the package version may result in changing
+              // the package configuration since the configuration always gets
+              // into the initial package build entry (potentially
+              // pre-entered, etc). If it wouldn't be true then we would also
+              // need to add the replacement version entry and re-collect from
+              // scratch.
+            }
+          }
+          else
             return nullptr;
         }
       }
       else
       {
+        // Treat the replacement of the existing dependent that is
+        // participating in the configuration negotiation also as a version
+        // replacement. This way we will not be treating the dependent as an
+        // existing on the re-collection (see query_existing_dependents() for
+        // details).
+        //
+        // Note: an existing dependent may not be configured as system.
+        //
+        if (pkg.selected != nullptr &&
+            (pkg.selected->version != pkg.available_version () ||
+             pkg.system))
+        {
+
+          for (const postponed_configuration& cfg: postponed_cfgs)
+          {
+            auto i (cfg.dependents.find (pk));
+
+            if (i != cfg.dependents.end () && i->second.existing)
+              replace_ver (pkg);
+          }
+        }
+
         // This is the first time we are adding this package name to the map.
         //
         l4 ([&]{trace << "add " << pkg.available_name_version_db ();});
 
-        // Note: copy; see emplace() below.
-        //
-        database& db (pkg.db); // Save before the move() call.
-        package_name n (pkg.available->id.name);
-        i = map_.emplace (config_package {db, move (n)},
-                          data_type {end (), move (pkg)}).first;
+        i = map_.emplace (move (pk), data_type {end (), move (pkg)}).first;
       }
 
       build_package& p (i->second.package);
 
+      if (vpb)
+        vpb (p, false /* scratch */);
+
       // Recursively collect build prerequisites, if requested.
       //
       // Note that detecting dependency cycles during the satisfaction phase
@@ -1195,16 +2712,21 @@ namespace bpkg
       // replaced once. So let's wait until some real use case proves this
       // reasoning wrong.
       //
-      if (dep_chain != nullptr)
+      if (recursive)
         collect_build_prerequisites (options,
                                      p,
                                      fdb,
                                      rpt_depts,
                                      apc,
+                                     initial_collection,
+                                     replaced_vers,
+                                     *dep_chain,
                                      postponed_repo,
                                      postponed_alts,
                                      0 /* max_alt_index */,
-                                     *dep_chain);
+                                     *postponed_deps,
+                                     postponed_cfgs,
+                                     *postponed_poss);
 
       return &p;
     }
@@ -1232,6 +2754,9 @@ namespace bpkg
     //   and, potentially, for its reconfigured existing prerequisites,
     //   recursively.
     //
+    // - For an existing dependent being re-evaluated to the specific
+    //   dependency position.
+    //
     // Note that for these cases, as it was said above, we can potentially
     // fail if the dependent is an orphan, but this is exactly what we need to
     // do in that case, since we won't be able to re-collect its dependencies.
@@ -1249,64 +2774,333 @@ namespace bpkg
     // with the lower indexes first (see collect_build_postponed() for
     // details).
     //
+    // Always postpone recursive collection of dependencies for a dependent
+    // with configuration clauses, recording them in postponed_deps (see
+    // postponed_dependencies for details) and also recording the dependent in
+    // postponed_cfgs (see postponed_configurations for details). If it turns
+    // out that some dependency of such a dependent has already been collected
+    // via some other dependent without configuration clauses, then throw the
+    // postpone_dependency exception. This exception is handled via
+    // re-collecting packages from scratch, but now with the knowledge about
+    // premature dependency collection. If it turns out that some dependency
+    // configuration has already been negotiated between some other
+    // dependents, then up-negotiate the configuration and throw
+    // retry_configuration exception so that the configuration refinement can
+    // be performed (see the collect lambda implementation for details on the
+    // configuration refinement machinery).
+    //
+    // If the package is a dependency of a configured dependent with
+    // configuration clause and needs to be reconfigured (being upgraded, has
+    // configuration specified, etc), then postpone its recursive collection
+    // by recording it in postponed_cfgs as a single-dependency cluster with
+    // an existing dependent (see postponed_configurations for details). If
+    // this dependent already belongs to some (being) negotiated configuration
+    // cluster with a greater dependency position then record this dependency
+    // position in postponed_poss and throw postpone_position. This exception
+    // is handled by re-collecting packages from scratch, but now with the
+    // knowledge about position this dependent needs to be re-evaluated to.
+    //
+    struct postpone_dependency: scratch_collection
+    {
+      package_key package;
+
+      explicit
+      postpone_dependency (package_key p)
+          : scratch_collection ("prematurely collected dependency"),
+            package (move (p))
+      {
+        scratch_collection::package = &package;
+      }
+    };
+
+    struct postpone_position: scratch_collection
+    {
+      postpone_position ()
+          : scratch_collection ("earlier dependency position") {}
+    };
+
     void
     collect_build_prerequisites (const pkg_build_options& options,
                                  build_package& pkg,
                                  const function<find_database_function>& fdb,
                                  const repointed_dependents& rpt_depts,
                                  const function<add_priv_cfg_function>& apc,
+                                 bool initial_collection,
+                                 replaced_versions& replaced_vers,
+                                 build_package_refs& dep_chain,
                                  postponed_packages* postponed_repo,
                                  postponed_packages* postponed_alts,
                                  size_t max_alt_index,
-                                 build_package_refs& dep_chain)
+                                 postponed_dependencies& postponed_deps,
+                                 postponed_configurations& postponed_cfgs,
+                                 postponed_positions& postponed_poss,
+                                 pair<size_t, size_t> reeval_pos =
+                                   make_pair(0, 0))
     {
+      // NOTE: don't forget to update collect_build_postponed() if changing
+      // anything in this function.
+      //
       tracer trace ("collect_build_prerequisites");
 
       assert (pkg.action && *pkg.action == build_package::build);
 
+      const package_name& nm (pkg.name ());
+      database& pdb (pkg.db);
+      package_key pk (pdb, nm);
+
+      bool reeval (reeval_pos.first != 0);
+
+      // The being re-evaluated dependent cannot be recursively collected yet.
+      // Also, we don't expect it being configured as system.
+      //
+      // Note that the configured package can still be re-evaluated after
+      // collect_build_prerequisites() has been called but didn't end up with
+      // the recursive collection.
+      //
+      assert (!reeval ||
+              ((!pkg.recursive_collection ||
+                !pkg.recollect_recursively (rpt_depts)) &&
+               !pkg.skeleton && !pkg.system));
+
+      // If this package is not being re-evaluated, is not yet collected
+      // recursively, needs to be reconfigured, and is not yet postponed, then
+      // check if it is a dependency of any dependent with configuration
+      // clause and postpone the collection if that's the case.
+      //
+      // The reason why we don't need to do this for the re-evaluated case is
+      // as follows: this logic is used for an existing dependent that is not
+      // otherwise built (e.g., reconfigured) which means its externally-
+      // imposed configuration (user, dependents) is not being changed.
+      //
+      if (!reeval                   &&
+          !pkg.recursive_collection &&
+          pkg.reconfigure ()        &&
+          postponed_cfgs.find_dependency (pk) == nullptr)
+      {
+        // If the dependent is being built, then check if it was re-evaluated
+        // to the position greater than the dependency position. Return true
+        // if that's the case, so this package is added to the resulting list
+        // and we can handle this situation below.
+        //
+        // Note that we rely on "small function object" optimization here.
+        //
+        const function<verify_dependent_build_function> verify (
+          [&postponed_cfgs]
+          (const package_key& pk, pair<size_t, size_t> pos)
+          {
+            for (const postponed_configuration& cfg: postponed_cfgs)
+            {
+              if (cfg.negotiated)
+              {
+                if (const pair<size_t, size_t>* p =
+                    cfg.existing_dependent_position (pk))
+                {
+                  if (p->first > pos.first)
+                    return true;
+                }
+              }
+            }
+
+            return false;
+          });
+
+        // Note that there can be multiple existing dependents for a
+        // dependency. Strictly speaking, we only need to add the first one
+        // with the assumption that the remaining dependents will also be
+        // considered comes the time for the negotiation. Let's, however,
+        // process all of them to detect the potential "re-evaluation on the
+        // greater dependency index" situation earlier. And, generally, have
+        // as much information as possible up front.
+        //
+        vector<existing_dependent> eds (
+          query_existing_dependents (trace,
+                                     pk.db,
+                                     pk.name,
+                                     replaced_vers,
+                                     rpt_depts,
+                                     verify));
+
+        if (!eds.empty ())
+        {
+          for (existing_dependent& ed: eds)
+          {
+            package_key dpk (ed.db, ed.selected->name);
+            size_t& di (ed.dependency_position.first);
+
+            const build_package* bp (&pkg);
+
+            // Check if this dependent needs to be re-evaluated to an earlier
+            // dependency position and, if that's the case, create the
+            // configuration cluster with this dependency instead.
+            //
+            // Note that if the replace flag is false, we proceed normally
+            // with the assumption that the dependency referred by the entry
+            // will be collected later and its configuration cluster will be
+            // created normally and will be negotiated earlier than the
+            // cluster being created for the current dependency (see
+            // collect_build_postponed() for details).
+            //
+            {
+              auto pi (postponed_poss.find (dpk));
+
+              if (pi != postponed_poss.end () && pi->second.first < di)
+              {
+                // If requested, override the first encountered non-replace
+                // position to replace. See collect_build_postponed () for
+                // details.
+                //
+                if (!pi->second.replace && postponed_poss.replace)
+                {
+                  pi->second.replace = true;
+                  postponed_poss.replace = false;
+                }
+
+                if (pi->second.replace)
+                {
+                  // Overwrite the existing dependent dependency information
+                  // and fall through to proceed as for the normal case.
+                  //
+                  bp = replace_existing_dependent_dependency (
+                    trace,
+                    options,
+                    ed, // Note: modified.
+                    pi->second,
+                    fdb,
+                    rpt_depts,
+                    apc,
+                    initial_collection,
+                    replaced_vers,
+                    postponed_cfgs);
+
+                  pk = package_key (bp->db, bp->name ());
+
+                  // Note that here we side-step the bogus logic (by not
+                  // setting the skipped flag) because in this case
+                  // (replace=true) our choices are either (potentially) bogus
+                  // or pathological (where we have evaluated too far). In
+                  // other words, the postponed entry may cause the depends
+                  // entry that triggered it to disappear (and thus, strictly
+                  // speaking, to become bogus) but if we cancel it, we will
+                  // be back to square one.
+                }
+              }
+            }
+
+            // Make sure that this existing dependent doesn't belong to any
+            // (being) negotiated configuration cluster with a greater
+            // dependency index. That would mean that this dependent has
+            // already been re-evaluated to this index and so cannot
+            // participate in the configuration negotiation of this earlier
+            // dependency.
+            //
+            for (const postponed_configuration& cfg: postponed_cfgs)
+            {
+              if (const pair<size_t, size_t>* p =
+                  cfg.existing_dependent_position (pk))
+              {
+                size_t ei (p->first);
+
+                if (di < ei && cfg.negotiated)
+                {
+                  // Feels like there cannot be an earlier position.
+                  //
+                  postponed_position pp (ed.dependency_position,
+                                         false /* replace */);
+
+                  auto p (postponed_poss.emplace (move (pk), pp));
+                  if (!p.second)
+                  {
+                    assert (p.first->second > pp);
+                    p.first->second = pp;
+                  }
+
+                  l5 ([&]{trace << "cannot cfg-postpone dependency "
+                                << bp->available_name_version_db ()
+                                << " of existing dependent " << *ed.selected
+                                << ed.db << " (index " << di
+                                << ") due to earlier dependency index " << ei
+                                << " in " << cfg << ", throwing "
+                                << "postpone_position";});
+
+                  // Don't print the "while satisfying..." chain.
+                  //
+                  dep_chain.clear ();
+
+                  throw postpone_position ();
+                }
+
+                if (di == ei)
+                {
+                  // For the negotiated cluster all the dependency packages
+                  // should have been added. For non-negotiated cluster we
+                  // cannot add the missing dependencies at the moment and
+                  // will do it as a part of the dependent re-evaluation.
+                  //
+                  assert (!cfg.negotiated);
+                }
+              }
+            }
+
+            l5 ([&]{trace << "cfg-postpone dependency "
+                          << bp->available_name_version_db ()
+                          << " of existing dependent " << *ed.selected
+                          << ed.db;});
+
+            postponed_cfgs.add (move (dpk), ed.dependency_position, move (pk));
+          }
+
+          return;
+        }
+      }
+
+      pkg.recursive_collection = true;
+
       if (pkg.system)
+      {
+        l5 ([&]{trace << "skip system " << pkg.available_name_version_db ();});
         return;
+      }
 
       const shared_ptr<available_package>& ap (pkg.available);
+      assert (ap != nullptr);
+
       const shared_ptr<selected_package>& sp (pkg.selected);
-      database& pdb (pkg.db);
 
       // True if this is an up/down-grade.
       //
-      bool ud (false);
+      bool ud (sp != nullptr && sp->version != pkg.available_version ());
 
       // If this is a repointed dependent, then it points to its prerequisite
       // replacements flag map (see repointed_dependents for details).
       //
-      const map<config_package, bool>* rpt_prereq_flags (nullptr);
+      const map<package_key, bool>* rpt_prereq_flags (nullptr);
 
-      assert (ap != nullptr);
-
-      // Bail out if this is a configured non-system package and no
-      // up/down-grade nor collecting prerequisite replacements are required.
-      //
-      // NOTE: remember to update the check condition in
-      // collect_order_dependents() if changing anything here.
+      // Bail out if this is a configured non-system package and no recursive
+      // collection is required.
       //
       bool src_conf (sp != nullptr &&
                      sp->state == package_state::configured &&
                      sp->substate != package_substate::system);
 
+      // The being re-evaluated dependent must be configured as a source
+      // package and should not be collected recursively (due to upgrade,
+      // etc).
+      //
+      assert (!reeval || (src_conf && !pkg.recollect_recursively (rpt_depts)));
+
       if (src_conf)
       {
-        ud = sp->version != pkg.available_version ();
-
-        repointed_dependents::const_iterator i (
-          rpt_depts.find (config_package {pdb, sp->name}));
+        repointed_dependents::const_iterator i (rpt_depts.find (pk));
 
         if (i != rpt_depts.end ())
           rpt_prereq_flags = &i->second;
 
-        if (!ud                         &&
-            rpt_prereq_flags == nullptr &&
-            (pkg.config_vars.empty () ||
-             !has_buildfile_clause (ap->dependencies)))
+        if (!reeval && !pkg.recollect_recursively (rpt_depts))
+        {
+          l5 ([&]{trace << "skip configured "
+                        << pkg.available_name_version_db ();});
           return;
+        }
       }
 
       // Iterate over dependencies, trying to unambiguously select a
@@ -1315,9 +3109,13 @@ namespace bpkg
       //
       const dependencies& deps (ap->dependencies);
 
-      // Must both be either present or not.
+      // The skeleton can be pre-initialized before the recursive collection
+      // starts (as a part of dependency configuration negotiation, etc). The
+      // dependencies and alternatives members must both be either present or
+      // not.
       //
-      assert (pkg.dependencies.has_value () == pkg.skeleton.has_value ());
+      assert ((!pkg.dependencies || pkg.skeleton) &&
+              pkg.dependencies.has_value () == pkg.alternatives.has_value ());
 
       // Note that the selected alternatives list can be filled partially (see
       // build_package::dependencies for details). In this case we continue
@@ -1325,32 +3123,36 @@ namespace bpkg
       //
       if (!pkg.dependencies)
       {
+        l5 ([&]{trace << (reeval ? "reeval " : "begin ")
+                      << pkg.available_name_version_db ();});
+
         pkg.dependencies = dependencies ();
+        pkg.alternatives = vector<size_t> ();
 
         if (size_t n = deps.size ())
+        {
           pkg.dependencies->reserve (n);
+          pkg.alternatives->reserve (n);
+        }
 
-        optional<dir_path> src_root (pkg.external_dir ());
-
-        optional<dir_path> out_root (
-          src_root && !pkg.disfigure
-          ? dir_path (pdb.config) /= pkg.name ().string ()
-          : optional<dir_path> ());
-
-        pkg.skeleton = package_skeleton (options,
-                                         pdb,
-                                         *ap,
-                                         pkg.config_vars,
-                                         move (src_root),
-                                         move (out_root));
+        if (!pkg.skeleton)
+          pkg.init_skeleton (options);
       }
+      else
+        l5 ([&]{trace << "resume " << pkg.available_name_version_db ();});
 
-      dependencies& sdeps (*pkg.dependencies);
+      dependencies&   sdeps (*pkg.dependencies);
+      vector<size_t>& salts (*pkg.alternatives);
+
+      assert (sdeps.size () == salts.size ()); // Must be parallel.
 
       // Check if there is nothing to collect anymore.
       //
       if (sdeps.size () == deps.size ())
+      {
+        l5 ([&]{trace << "end " << pkg.available_name_version_db ();});
         return;
+      }
 
       // Show how we got here if things go wrong.
       //
@@ -1379,8 +3181,24 @@ namespace bpkg
 
       package_skeleton& skel (*pkg.skeleton);
 
+      auto fail_reeval = [&pkg] ()
+      {
+        fail << "unable to re-create dependency information of already "
+             << "configured package " << pkg.available_name_version_db () <<
+          info << "likely cause is change in external environment" <<
+          info << "consider resetting the build configuration";
+      };
+
+      bool postponed (false);
+      bool reevaluated (false);
+
       for (size_t di (sdeps.size ()); di != deps.size (); ++di)
       {
+        // Fail if we missed the re-evaluation target position for any reason.
+        //
+        if (reeval && di == reeval_pos.first) // Note: reeval_pos is 1-based.
+          fail_reeval ();
+
         const dependency_alternatives_ex& das (deps[di]);
 
         // Add an empty alternatives list into the selected dependency list if
@@ -1388,9 +3206,10 @@ namespace bpkg
         //
         dependency_alternatives_ex sdas (das.buildtime, das.comment);
 
-        if (toolchain_buildtime_dependency (options, das, pkg.name ()))
+        if (toolchain_buildtime_dependency (options, das, &nm))
         {
           sdeps.push_back (move (sdas));
+          salts.push_back (0);           // Keep parallel to sdeps.
           continue;
         }
 
@@ -1398,7 +3217,7 @@ namespace bpkg
         // Add an empty alternatives list into the selected dependency list if
         // there are none.
         //
-        small_vector<reference_wrapper<const dependency_alternative>, 2> edas;
+        build_package::dependency_alternatives_refs edas;
 
         if (pkg.postponed_dependency_alternatives)
         {
@@ -1407,16 +3226,20 @@ namespace bpkg
         }
         else
         {
-          for (const dependency_alternative& da: das)
+          for (size_t i (0); i != das.size (); ++i)
           {
-            if (!da.enable || skel.evaluate_enable (*da.enable, di))
-              edas.push_back (da);
+            const dependency_alternative& da (das[i]);
+
+            if (!da.enable ||
+                skel.evaluate_enable (*da.enable, make_pair (di, i)))
+              edas.push_back (make_pair (ref (da), i));
           }
         }
 
         if (edas.empty ())
         {
           sdeps.push_back (move (sdas));
+          salts.push_back (0);           // Keep parallel to sdeps.
           continue;
         }
 
@@ -1483,6 +3306,7 @@ namespace bpkg
         };
         auto precollect = [&options,
                            &pkg,
+                           &nm,
                            &pdb,
                            ud,
                            &fdb,
@@ -1490,6 +3314,7 @@ namespace bpkg
                            &apc,
                            postponed_repo,
                            &dep_chain,
+                           &trace,
                            this]
                           (const dependency_alternative& da,
                            bool buildtime,
@@ -1523,9 +3348,10 @@ namespace bpkg
             bool system    (false);
             bool specified (false);
 
-            // If the user specified the desired dependency version constraint,
-            // then we will use it to overwrite the constraint imposed by the
-            // dependent package, checking that it is still satisfied.
+            // If the user specified the desired dependency version
+            // constraint, then we will use it to overwrite the constraint
+            // imposed by the dependent package, checking that it is still
+            // satisfied.
             //
             // Note that we can't just rely on the execution plan refinement
             // that will pick up the proper dependency version at the end of
@@ -1575,12 +3401,12 @@ namespace bpkg
                   if (dr != nullptr)
                     *dr << error << "unable to satisfy constraints on package "
                         << dn <<
-                      info << pkg.name () << pdb << " depends on (" << dn
+                      info << nm << pdb << " depends on (" << dn
                            << " " << *dp.constraint << ")" <<
                       info << c.dependent << c.db << " depends on (" << dn
                            << " " << c.value << ")" <<
                       info << "specify " << dn << " version to satisfy "
-                           << pkg.name () << " constraint";
+                           << nm << " constraint";
 
                   return precollect_result (false /* postpone */);
                 }
@@ -1644,7 +3470,7 @@ namespace bpkg
               //
               if (rpt_prereq_flags != nullptr)
               {
-                auto i (rpt_prereq_flags->find (config_package {*ddb, dn}));
+                auto i (rpt_prereq_flags->find (package_key {*ddb, dn}));
 
                 bool unamended   (i == rpt_prereq_flags->end ());
                 bool replacement (!unamended && i->second);
@@ -1675,17 +3501,18 @@ namespace bpkg
               {
                 system = dsp->system ();
 
-                optional<version_constraint> vc (
-                  !system
-                  ? version_constraint (dsp->version)
-                  : optional<version_constraint> ());
+                version_constraint vc (dsp->version);
 
                 // First try to find an available package for this exact
                 // version, falling back to ignoring version revision and
                 // iteration. In particular, this handles the case where a
                 // package moves from one repository to another (e.g., from
-                // testing to stable). For a system package we pick the latest
-                // one (its exact version doesn't really matter).
+                // testing to stable). For a system package we will try to
+                // find the available package that matches the selected
+                // package version (preferable for the configuration
+                // negotiation machinery) and, if fail, fallback to picking
+                // the latest one (its exact version doesn't really matter in
+                // this case).
                 //
                 // It seems reasonable to search for the package in the
                 // repositories explicitly added by the user if the selected
@@ -1703,11 +3530,11 @@ namespace bpkg
                                            true /* prereq */,
                                            true /* revision */);
 
-                  // Note: constraint is not present for the system package,
-                  // so there is no sense to repeat the attempt.
-                  //
-                  if (dap == nullptr && !system)
+                  if (dap == nullptr)
                     rp = find_available_one (dbs, dn, vc);
+
+                  if (dap == nullptr && system)
+                    rp = find_available_one (dbs, dn, nullopt);
                 }
                 else if (af != nullptr)
                 {
@@ -1717,8 +3544,11 @@ namespace bpkg
                                            true /* prereq */,
                                            true /* revision */);
 
-                  if (dap == nullptr && !system)
+                  if (dap == nullptr)
                     rp = find_available_one (dn, vc, af);
+
+                  if (dap == nullptr && system)
+                    rp = find_available_one (dn, nullopt, af);
                 }
 
                 // A stub satisfies any version constraint so we weed them out
@@ -1884,9 +3714,9 @@ namespace bpkg
             // the same configuration with the build2 module it depends upon
             // is an error.
             //
-            if (buildtime                    &&
-                !build2_module (pkg.name ()) &&
-                build2_module (dn)           &&
+            if (buildtime           &&
+                !build2_module (nm) &&
+                build2_module (dn)  &&
                 pdb == *ddb)
             {
               assert (dr == nullptr); // Should fail on the "silent" run.
@@ -1926,7 +3756,7 @@ namespace bpkg
               // for this package version. Consider this scenario as an
               // example: hello/1.0.0 and libhello/1.0.0 in stable and
               // libhello/2.0.0 in testing. As a prerequisite of hello, which
-              // version should libhello resolve to?  While one can probably
+              // version should libhello resolve to? While one can probably
               // argue either way, resolving it to 1.0.0 is the conservative
               // choice and the user can always override it by explicitly
               // building libhello.
@@ -1959,13 +3789,17 @@ namespace bpkg
               // problematic dependent, expecting that some other one will
               // find the appropriate version in its repositories.
               //
-              // For a system package we pick the latest version just to make
-              // sure the package is recognized. An unrecognized package means
-              // the broken/stale repository (see below).
+              // For a system package we will try to find the available
+              // package that matches the constraint (preferable for the
+              // configuration negotiation machinery) and, if fail, fallback
+              // to picking the latest one just to make sure the package is
+              // recognized. An unrecognized package means the broken/stale
+              // repository (see below).
               //
-              rp = find_available_one (dn,
-                                       !system ? d.constraint : nullopt,
-                                       af);
+              rp = find_available_one (dn, d.constraint, af);
+
+              if (dap == nullptr && system && d.constraint)
+                rp = find_available_one (dn, nullopt, af);
 
               if (dap == nullptr)
               {
@@ -1976,6 +3810,12 @@ namespace bpkg
                   //
                   assert (dr == nullptr);
 
+                  l5 ([&]{trace << "rep-postpone dependent "
+                                << pkg.available_name_version_db ()
+                                << " due to dependency " << dp
+                                << " and user-specified constraint "
+                                << *dep_constr;});
+
                   postponed_repo->insert (&pkg);
                   return precollect_result (true /* postpone */);
                 }
@@ -2004,7 +3844,7 @@ namespace bpkg
                         (!dep_constr || !wildcard (*dep_constr)))
                       *dr << ' ' << *d.constraint;
 
-                    *dr << ") of package " << pkg.name () << pdb <<
+                    *dr << ") of package " << nm << pdb <<
                       info << "available " << dn << " versions:";
 
                     for (const shared_ptr<available_package>& ap: aps)
@@ -2013,7 +3853,7 @@ namespace bpkg
                   else
                   {
                     *dr << "no package available for dependency " << dn
-                        << " of package " << pkg.name () << pdb;
+                        << " of package " << nm << pdb;
                   }
 
                   // Avoid printing this if the dependent package is external
@@ -2054,7 +3894,7 @@ namespace bpkg
                 {
                   if (dr != nullptr)
                     *dr << error << "dependency " << d << " of package "
-                        << pkg.name () << " is not available in source" <<
+                        << nm << " is not available in source" <<
                       info << "specify ?sys:" << dn << " if it is available "
                            << "from the system";
 
@@ -2065,7 +3905,7 @@ namespace bpkg
                 {
                   if (dr != nullptr)
                     *dr << error << "dependency " << d << " of package "
-                        << pkg.name () << " is not available in source" <<
+                        << nm << " is not available in source" <<
                       info << package_string (dn,
                                               *dap->system_version (*ddb),
                                               true /* system */)
@@ -2114,8 +3954,7 @@ namespace bpkg
                 {
                   using constraint_type = build_package::constraint_type;
 
-                  constraint_type c1 {
-                    pkg.db, pkg.name ().string (), *d.constraint};
+                  constraint_type c1 {pdb, nm.string (), *d.constraint};
 
                   if (!satisfies (v2, c1.value))
                   {
@@ -2170,20 +4009,49 @@ namespace bpkg
           return precollect_result (move (r), reused);
         };
 
-        // Collect the previously collected pre-builds.
+        // Try to collect the previously collected pre-builds.
+        //
+        // Return false if the dependent has configuration clauses and is
+        // postponed until dependencies configuration negotiation.
         //
         auto collect = [&options,
                         &pkg,
                         &pdb,
+                        &nm,
+                        &pk,
                         &fdb,
                         &rpt_depts,
                         &apc,
+                        initial_collection,
+                        &replaced_vers,
+                        &dep_chain,
                         postponed_repo,
                         postponed_alts,
-                        &dep_chain,
+                        &postponed_deps,
+                        &postponed_cfgs,
+                        &postponed_poss,
+                        &di,
+                        reeval,
+                        &reeval_pos,
+                        &reevaluated,
+                        &fail_reeval,
+                        &trace,
                         this]
-                       (prebuilds&& bs)
+                       (const dependency_alternative& da,
+                        size_t dai,
+                        prebuilds&& bs)
         {
+          // Dependency alternative position.
+          //
+          pair<size_t, size_t> dp (di + 1, dai + 1);
+
+          if (reeval                        &&
+              dp.first  == reeval_pos.first &&
+              dp.second != reeval_pos.second)
+            fail_reeval ();
+
+          postponed_configuration::packages cfg_deps;
+
           for (prebuild& b: bs)
           {
             build_package bp {
@@ -2192,22 +4060,24 @@ namespace bpkg
               b.selected,
               b.available,
               move (b.repository_fragment),
-              nullopt,                             // Dependencies.
-              nullopt,                             // Package skeleton.
-              nullopt,                             // Postponed dependency alternatives.
-              nullopt,                             // Hold package.
-              nullopt,                             // Hold version.
-              {},                                  // Constraints.
+              nullopt,                    // Dependencies.
+              nullopt,                    // Dependencies alternatives.
+              nullopt,                    // Package skeleton.
+              nullopt,                    // Postponed dependency alternatives.
+              false,                      // Recursive collection.
+              nullopt,                    // Hold package.
+              nullopt,                    // Hold version.
+              {},                         // Constraints.
               b.system,
-              false,                               // Keep output directory.
-              false,                               // Disfigure (from-scratch reconf).
-              false,                               // Configure-only.
-              nullopt,                             // Checkout root.
-              false,                               // Checkout purge.
-              strings (),                          // Configuration variables.
-              {config_package {pdb, pkg.name ()}}, // Required by (dependent).
-              true,                                // Required by dependents.
-              0};                                  // State flags.
+              false,                      // Keep output directory.
+              false,                      // Disfigure (from-scratch reconf).
+              false,                      // Configure-only.
+              nullopt,                    // Checkout root.
+              false,                      // Checkout purge.
+              strings (),                 // Configuration variables.
+              {pk},                       // Required by (dependent).
+              true,                       // Required by dependents.
+              0};                         // State flags.
 
             const optional<version_constraint>& constraint (
               b.dependency.constraint);
@@ -2220,9 +4090,7 @@ namespace bpkg
             // constraints for completeness.
             //
             if (constraint)
-              bp.constraints.emplace_back (pdb,
-                                           pkg.name ().string (),
-                                           *constraint);
+              bp.constraints.emplace_back (pdb, nm.string (), *constraint);
 
             // Now collect this prerequisite. If it was actually collected
             // (i.e., it wasn't already there) and we are forcing a downgrade
@@ -2242,71 +4110,591 @@ namespace bpkg
             // build sys:bar/1
             // build foo ?sys:bar/2
             //
-            // Note: recursive.
+            // Pass the function which verifies we don't try to force
+            // up/downgrade of the held version and makes sure we don't print
+            // the dependency chain if replace_version will be thrown.
+            //
+            // Also note that we rely on "small function object" optimization
+            // here.
+            //
+            struct
+            {
+              const build_package& dependent;
+              const prebuild&      prerequisite;
+            } dpn {pkg, b};
+
+            const function<verify_package_build_function> verify (
+              [&dpn, &dep_chain] (const build_package& p, bool scratch)
+              {
+                const prebuild&      prq (dpn.prerequisite);
+                const build_package& dep (dpn.dependent);
+
+                if (prq.force && !prq.specified_dependency)
+                {
+                  // Fail if the version is held. Otherwise, warn if the
+                  // package is held.
+                  //
+                  bool f (prq.selected->hold_version);
+                  bool w (!f && prq.selected->hold_package);
+
+                  // Note that there is no sense to warn or inform the user if
+                  // we are about to start re-collection from scratch.
+                  //
+                  // @@ It seems that we may still warn/inform multiple times
+                  //    about the same package if we start from scratch. The
+                  //    intermediate diagnostics can probably be irrelevant to
+                  //    the final result.
+                  //
+                  //    Perhaps what we should do is queue the diagnostics and
+                  //    then, if the run is not scratched, issues it. And if
+                  //    it is scratched, then drop it.
+                  //
+                  if (f || ((w || verb >= 2) && !scratch))
+                  {
+                    const version& av (p.available_version ());
+
+                    bool u (av > prq.selected->version);
+                    bool c (prq.dependency.constraint);
+
+                    diag_record dr;
+
+                    (f ? dr << fail :
+                     w ? dr << warn :
+                     dr << info)
+                      << "package " << dep.name () << dep.db
+                      << " dependency on " << (c ? "(" : "") << prq.dependency
+                      << (c ? ")" : "") << " is forcing "
+                      << (u ? "up" : "down") << "grade of " << *prq.selected
+                      << prq.db << " to ";
+
+                    // Print both (old and new) package names in full if the
+                    // system attribution changes.
+                    //
+                    if (prq.selected->system ())
+                      dr << p.available_name_version ();
+                    else
+                      dr << av; // Can't be a system version so is never wildcard.
+
+                    if (prq.selected->hold_version)
+                      dr << info << "package version " << *prq.selected
+                         << prq.db<< " is held";
+
+                    if (f)
+                      dr << info << "explicitly request version "
+                         << (u ? "up" : "down") << "grade to continue";
+                  }
+                }
+
+                // Don't print the "while satisfying..." chain if we are about
+                // to re-collect the packages.
+                //
+                if (scratch)
+                  dep_chain.clear ();
+              });
+
+            // Note: non-recursive.
             //
-            const build_package* p (
+            build_package* p (
               collect_build (options,
                              move (bp),
                              fdb,
                              rpt_depts,
                              apc,
-                             postponed_repo,
-                             postponed_alts,
-                             &dep_chain));
+                             initial_collection,
+                             replaced_vers,
+                             postponed_cfgs,
+                             nullptr /* dep_chain */,
+                             nullptr /* postponed_repo */,
+                             nullptr /* postponed_alts */,
+                             nullptr /* postponed_deps */,
+                             nullptr /* postponed_poss */,
+                             verify));
+
+            package_key dpk (b.db, b.available->id.name);
+
+            // Do not collect prerequisites recursively for dependent
+            // re-evaluation. Instead, if the re-evaluation position is
+            // reached, collect the dependency packages to add them to the
+            // existing dependent's cluster.
+            //
+            if (reeval)
+            {
+              if (dp == reeval_pos)
+                cfg_deps.push_back (move (dpk));
+
+              continue;
+            }
+
+            // Do not recursively collect a dependency of a dependent with
+            // configuration clauses, which could be this or some other
+            // (indicated by the presence in postponed_deps) dependent. In the
+            // former case if the prerequisites were prematurely collected,
+            // throw postpone_dependency.
+            //
+            // Note that such a dependency will be recursively collected
+            // directly right after the configuration negotiation (rather than
+            // via the dependent).
+            //
+            bool collect_prereqs (p != nullptr);
 
-            if (p != nullptr && b.force && !b.specified_dependency)
             {
-              // Fail if the version is held. Otherwise, warn if the package is
-              // held.
-              //
-              bool f (b.selected->hold_version);
-              bool w (!f && b.selected->hold_package);
+              build_package* bp (entered_build (dpk));
+              assert (bp != nullptr);
 
-              if (f || w || verb >= 2)
+              if (da.prefer || da.require)
               {
-                const version& av (p->available_version ());
+                // Indicate that the dependent with configuration clauses is
+                // present.
+                //
+                {
+                  auto i (postponed_deps.find (dpk));
 
-                bool u (av > b.selected->version);
-                bool c (constraint);
+                  // Do not override postponements recorded during postponed
+                  // collection phase with those recorded during initial
+                  // phase.
+                  //
+                  if (i == postponed_deps.end ())
+                  {
+                    postponed_deps.emplace (dpk,
+                                            postponed_dependency {
+                                              false /* without_config */,
+                                              true  /* with_config */,
+                                              initial_collection});
+                  }
+                  else
+                    i->second.with_config = true;
+                }
 
-                diag_record dr;
+                // Prematurely collected before we saw any config clauses.
+                //
+                if (bp->recursive_collection &&
+                    postponed_cfgs.find_dependency (dpk) == nullptr)
+                {
+                  l5 ([&]{trace << "cannot cfg-postpone dependency "
+                                << bp->available_name_version_db ()
+                                << " of dependent "
+                                << pkg.available_name_version_db ()
+                                << " (collected prematurely), "
+                                << "throwing postpone_dependency";});
+
+                  // Don't print the "while satisfying..." chain.
+                  //
+                  dep_chain.clear ();
 
-                (f ? dr << fail :
-                 w ? dr << warn :
-                 dr << info)
-                  << "package " << pkg.name () << pdb << " dependency on "
-                  << (c ? "(" : "") << b.dependency << (c ? ")" : "")
-                  << " is forcing " << (u ? "up" : "down") << "grade of "
-                  << *b.selected << b.db << " to ";
+                  throw postpone_dependency (move (dpk));
+                }
 
-                // Print both (old and new) package names in full if the system
-                // attribution changes.
+                // Postpone until (re-)negotiation.
                 //
-                if (b.selected->system ())
-                  dr << p->available_name_version ();
+                l5 ([&]{trace << "cfg-postpone dependency "
+                              << bp->available_name_version_db ()
+                              << " of dependent "
+                              << pkg.available_name_version_db ();});
+
+                cfg_deps.push_back (move (dpk));
+
+                collect_prereqs = false;
+              }
+              else
+              {
+                // Indicate that the dependent without configuration clauses
+                // is also present.
+                //
+                auto i (postponed_deps.find (dpk));
+                if (i != postponed_deps.end ())
+                {
+                  l5 ([&]{trace << "dep-postpone dependency "
+                                << bp->available_name_version_db ()
+                                << " of dependent "
+                                << pkg.available_name_version_db ();});
+
+                  i->second.wout_config = true;
+
+                  collect_prereqs = false;
+                }
                 else
-                  dr << av; // Can't be a system version so is never wildcard.
+                {
+                  l5 ([&]{trace << "no cfg-clause for dependency "
+                                << bp->available_name_version_db ()
+                                << " of dependent "
+                                << pkg.available_name_version_db ();});
+                }
+              }
+            }
+
+            if (collect_prereqs)
+              collect_build_prerequisites (options,
+                                           *p,
+                                           fdb,
+                                           rpt_depts,
+                                           apc,
+                                           initial_collection,
+                                           replaced_vers,
+                                           dep_chain,
+                                           postponed_repo,
+                                           postponed_alts,
+                                           0 /* max_alt_index */,
+                                           postponed_deps,
+                                           postponed_cfgs,
+                                           postponed_poss);
+          }
+
+          // If this dependent has any dependencies with configurations
+          // clauses, then we need to deal with that.
+          //
+          // This is what we refer to as the "up-negotiation" where we
+          // negotiate the configuration of dependents that could not be
+          // postponed and handled all at once during "initial negotiation" in
+          // collect_build_postponed().
+          //
+          if (!cfg_deps.empty ())
+          {
+            // Re-evaluation is a special case (it happens during cluster
+            // negotiation; see collect_build_postponed()).
+            //
+            if (reeval)
+            {
+              reevaluated = true;
+
+              // Note: the dependent may already exist in the cluster with a
+              // subset of dependencies.
+              //
+              postponed_configuration& cfg (
+                postponed_cfgs.add (pk,
+                                    true /* existing */,
+                                    dp,
+                                    cfg_deps).first);
+
+              // Can we merge clusters as a result? Seems so.
+              //
+              // - Simple case is if the cluster(s) being merged are not
+              //   negotiated. Then perhaps we could handle this via the same
+              //   logic that handles the addition of extra dependencies.
+              //
+              // - For the complex case, perhaps just making the resulting
+              //   cluster shadow and rolling back, just like in the other
+              //   case (non-existing dependent).
+              //
+              // Note: this is a special case of the below more general logic.
+              //
+              // Also note that we can distinguish the simple case by the fact
+              // that the resulting cluster is not negotiated. Note however,
+              // that in this case it is guaranteed that all the involved
+              // clusters will be merged into the cluster which the being
+              // re-evaluated dependent belongs to since this cluster (while
+              // not being negotiated) already has non-zero depth (see
+              // collect_build_postponed() for details).
+              //
+              assert (cfg.depth != 0);
+
+              if (cfg.negotiated)
+              {
+                l5 ([&]{trace << "re-evaluating dependent "
+                              << pkg.available_name_version_db ()
+                              << " involves negotiated configurations and "
+                              << "results in " << cfg << ", throwing "
+                              << "merge_configuration";});
+
+                // Don't print the "while satisfying..." chain.
+                //
+                dep_chain.clear ();
 
-                if (b.selected->hold_version)
-                  dr << info << "package version " << *b.selected << b.db
-                     << " is held";
+                throw merge_configuration {cfg.depth};
+              }
+
+              l5 ([&]{trace << "re-evaluating dependent "
+                            << pkg.available_name_version_db ()
+                            << " results in " << cfg;});
+
+              return false;
+            }
+
+            // As a first step add this dependent/dependencies to one of the
+            // new/existing postponed_configuration clusters, which could
+            // potentially cause some of them to be merged. Here are the
+            // possibilities and what we should do in each case.
+            //
+            // 1. Got added to a new cluster -- this dependent got postponed
+            //    and we return false.
+            //
+            // 2. Got added to an existing non-yet-negotiated cluster (which
+            //    could potentially involve merging a bunch of them) -- ditto.
+            //
+            // 3. Got added to an existing already-[being]-negotiated cluster
+            //    (which could potentially involve merging a bunch of them,
+            //    some negotiated, some being negotiated, and some not yet
+            //    negotiated) -- see below logic.
+            //
+            // Note that if a dependent is postponed, it will be recursively
+            // recollected right after the configuration negotiation.
+
+            // Note: don't move the argument from since may be needed for
+            // constructing exception.
+            //
+            pair<postponed_configuration&, optional<bool>> r (
+              postponed_cfgs.add (pk, false /* existing */, dp, cfg_deps));
+
+            postponed_configuration& cfg (r.first);
+
+            if (cfg.depth == 0)
+              return false; // Cases (1) or (2).
+            else
+            {
+              // Case (3).
+              //
+              // There is just one complication:
+              //
+              // If all the merged clusters are already negotiated, then all
+              // is good: all the dependencies in cfg_deps have been collected
+              // recursively as part of the configuration negotiation (because
+              // everything in this cluster is already negotiated) and we can
+              // return true (no need to postpone any further steps).
+              //
+              // But if we merged clusters not yet negotiated, or, worse,
+              // being in the middle of negotiation, then we need to get this
+              // merged cluster into the fully negotiated state. The way we do
+              // it is by throwing merge_configuration (see below).
+              //
+              // When we are back here after throwing merge_configuration,
+              // then all the clusters have been pre-merged and our call to
+              // add() shouldn't have added any new cluster. In this case the
+              // cluster can either be already negotiated or being negotiated
+              // and we can proceed as in the "everything is negotiated case"
+              // above (we just need to get the the dependencies that we care
+              // about into the recursively collected state).
+              //
+
+              // To recap, r.second values mean:
+              //
+              //   absent  -- shadow cluster-based merge is/being negotiated
+              //   false   -- some non or being negotiated
+              //   true    -- all have been negotiated
+              //
+              if (r.second && !*r.second)
+              {
+                // The partially negotiated case.
+                //
+                // Handling this in a straightforward way is not easy due to
+                // the being negotiated cases -- we have code up the stack
+                // that is in the middle of the negotiation logic.
+                //
+                // Another idea is to again throw to the outer try/catch frame
+                // (thus unwinding all the being negotiated code) and complete
+                // the work there. The problem with this approach is that
+                // without restoring the state we may end up with unrelated
+                // clusters that will have no corresponding try-catch frames
+                // (because we may unwind them in the process).
+                //
+                // So the approach we will use is the "shadow" idea for
+                // merging clusters. Specifically, we throw
+                // merge_configuration to the outer try/catch. At the catch
+                // site we make the newly merged cluster a shadow of the
+                // restored cluster and retry the same steps similar to
+                // retry_configuration. As we redo these steps, we consult the
+                // shadow cluster and if the dependent/dependency entry is
+                // there, then instead of adding it to another (new/existing)
+                // cluster that would later be merged into this non-shadow
+                // cluster, we add it directly to the non-shadow cluster
+                // (potentially merging other cluster which it feels like by
+                // definition should all be already fully negotiated). The end
+                // result is that once we reach this point again, there will
+                // be nothing to merge.
+                //
+                // The shadow check is part of postponed_configs::add().
+                //
+                l5 ([&]{trace << "cfg-postponing dependent "
+                              << pkg.available_name_version_db ()
+                              << " merges non-negotiated and/or being "
+                              << "negotiated configurations in and results in "
+                              << cfg << ", throwing merge_configuration";});
+
+                // Don't print the "while satisfying..." chain.
+                //
+                dep_chain.clear ();
+
+                throw merge_configuration {cfg.depth};
+              }
+
+              // Up-negotiate the configuration and if it has changed, throw
+              // retry_configuration to the try/catch frame corresponding to
+              // the negotiation of the outermost merged cluster in order to
+              // retry the same steps (potentially refining the configuration
+              // as we go along) and likely (but not necessarily) ending up
+              // here again, at which point we up-negotiate again with the
+              // expectation that the configuration won't change (but if it
+              // does, then we throw again and do another refinement pass).
+              //
+              // In a sense, semantically, we should act like a one more
+              // iteration of the initial negotiation loop with the exception
+              // acting like a request to restart the refinement process from
+              // the beginning.
+              //
+              bool changed;
+              {
+                // Similar to initial negotiation, resolve package skeletons
+                // for this dependent and its dependencies.
+                //
+                package_skeleton* dept;
+                {
+                  build_package* b (entered_build (pk));
+                  assert (b != nullptr && b->skeleton);
+                  dept = &*b->skeleton;
+                }
+
+                // If a dependency has already been recursively collected,
+                // then we can no longer call reload_defaults() or
+                // verify_sensible() on its skeleton. We could reset it, but
+                // then we wouldn't be able to continue using it if
+                // negotiate_configuration() below returns false. So it seems
+                // the most sensible approach is to make a temporary copy and
+                // reset that.
+                //
+                small_vector<reference_wrapper<package_skeleton>, 1> depcs;
+                forward_list<package_skeleton> depcs_storage; // Ref stability.
+                {
+                  depcs.reserve (cfg_deps.size ());
+                  for (const package_key& pk: cfg_deps)
+                  {
+                    build_package* b (entered_build (pk));
+                    assert (b != nullptr);
+
+                    package_skeleton* depc;
+                    if (b->recursive_collection)
+                    {
+                      assert (b->skeleton);
+
+                      depcs_storage.push_front (*b->skeleton);
+                      depc = &depcs_storage.front ();
+                      depc->reset ();
+                    }
+                    else
+                      depc = &(b->skeleton
+                               ? *b->skeleton
+                               : b->init_skeleton (options));
+
+                    depcs.push_back (*depc);
+                  }
+                }
+
+                changed = negotiate_configuration (
+                  cfg.dependency_configurations, *dept, dp, depcs);
+              }
+
+              // If the configuration hasn't changed, then we carry on.
+              // Otherwise, retry the negotiation from the beginning to
+              // refine the resulting configuration (see the catch block
+              // for retry_configuration).
+              //
+              if (changed)
+              {
+                l5 ([&]{trace << "cfg-postponing dependent "
+                              << pkg.available_name_version_db ()
+                              << " involves (being) negotiated configurations "
+                              << "and results in " << cfg
+                              << ", throwing retry_configuration";});
+
+                // Don't print the "while satisfying..." chain.
+                //
+                dep_chain.clear ();
+
+                throw retry_configuration {cfg.depth, move (pk)};
+              }
+
+              l5 ([&]{trace << "configuration for cfg-postponed "
+                            << "dependencies of dependent "
+                            << pkg.available_name_version_db () << " is "
+                            << (r.second ? "" : "shadow-") << "negotiated";});
+
+              // Note that even in the fully negotiated case we may still add
+              // extra dependencies to this cluster which we still need to
+              // configure and recursively collect before indicating to the
+              // caller (returning true) that we are done with this depends
+              // value and the dependent is not postponed.
+              //
+              for (const package_key& p: cfg_deps)
+              {
+                build_package* b (entered_build (p));
+                assert (b != nullptr);
+
+                // Reconfigure the configured dependencies (see
+                // collect_build_postponed() for details).
+                //
+                if (b->selected != nullptr &&
+                    b->selected->state == package_state::configured)
+                  b->flags |= build_package::adjust_reconfigure;
+
+                if (!b->recursive_collection)
+                {
+                  l5 ([&]{trace << "collecting cfg-postponed dependency "
+                                << b->available_name_version_db ()
+                                << " of dependent "
+                                << pkg.available_name_version_db ();});
+
+                  // Similar to the inital negotiation case, verify and set
+                  // the dependent configuration for this dependency.
+                  //
+                  {
+                    assert (b->skeleton); // Should have been init'ed above.
+
+                    const package_configuration& pc (
+                      cfg.dependency_configurations[p]);
+
+                    pair<bool, string> pr (b->skeleton->available != nullptr
+                                           ? b->skeleton->verify_sensible (pc)
+                                           : make_pair (true, string ()));
+
+                    if (!pr.first)
+                    {
+                      diag_record dr (fail);
+                      dr << "unable to negotiate sensible configuration for "
+                         << "dependency " << p << '\n'
+                         << "  " << pr.second;
+
+                      dr << info << "negotiated configuration:\n";
+                      pc.print (dr, "    ");
+                    }
+
+                    b->skeleton->dependent_config (pc);
+                  }
 
-                if (f)
-                  dr << info << "explicitly request version "
-                     << (u ? "up" : "down") << "grade to continue";
+                  collect_build_prerequisites (options,
+                                               *b,
+                                               fdb,
+                                               rpt_depts,
+                                               apc,
+                                               initial_collection,
+                                               replaced_vers,
+                                               dep_chain,
+                                               postponed_repo,
+                                               postponed_alts,
+                                               0 /* max_alt_index */,
+                                               postponed_deps,
+                                               postponed_cfgs,
+                                               postponed_poss);
+                }
+                else
+                  l5 ([&]{trace << "dependency "
+                                << b->available_name_version_db ()
+                                << " of dependent "
+                                << pkg.available_name_version_db ()
+                                << " is already (being) recursively "
+                                << "collected, skipping";});
               }
+
+              return true;
             }
           }
+
+          return true;
         };
 
         // Select a dependency alternative, copying it alone into the
-        // resulting dependencies list, evaluating its reflect clause, if
-        // present, and collecting its dependency builds.
+        // resulting dependencies list and evaluating its reflect clause, if
+        // present.
         //
         bool selected (false);
-        auto select = [&sdeps, &sdas, &skel, di, &collect, &selected]
-                      (const dependency_alternative& da,
-                       prebuilds&& bs)
+        auto select = [&sdeps, &salts, &sdas, &skel, di, &selected]
+                      (const dependency_alternative& da, size_t dai)
         {
           assert (sdas.empty ());
 
@@ -2320,20 +4708,18 @@ namespace bpkg
                              da /* dependencies */);
 
           sdeps.push_back (move (sdas));
+          salts.push_back (dai);
 
           if (da.reflect)
-            skel.evaluate_reflect (*da.reflect, di);
-
-          collect (move (bs));
+            skel.evaluate_reflect (*da.reflect, make_pair (di, dai));
 
           selected = true;
         };
 
         // Postpone the prerequisite builds collection, optionally inserting
-        // the package to the postpones set (can potentially already be there)
-        // and saving the enabled alternatives.
+        // the package to the postponements set (can potentially already be
+        // there) and saving the enabled alternatives.
         //
-        bool postponed (false);
         auto postpone = [&pkg, &edas, &postponed]
                         (postponed_packages* postpones)
         {
@@ -2357,10 +4743,19 @@ namespace bpkg
         // decisions" mode and select the alternative ignoring the current
         // prerequisites.
         //
+        // Note though, that if we are re-evaluating an existing dependent
+        // then we fail if we didn't succeed in the "recreate dependency
+        // decisions" mode.
+        //
         const package_prerequisites* prereqs (src_conf && !ud
                                               ? &sp->prerequisites
                                               : nullptr);
 
+        // During the dependent re-evaluation we always try to reproduce the
+        // existing setup.
+        //
+        assert (!reeval || prereqs != nullptr);
+
         for (;;)
         {
           // The index and pre-collection result of the first satisfactory
@@ -2374,7 +4769,7 @@ namespace bpkg
 
           for (size_t i (0); i != edas.size (); ++i)
           {
-            const dependency_alternative& da (edas[i]);
+            const dependency_alternative& da (edas[i].first);
 
             precollect_result r (precollect (da, das.buildtime, prereqs));
 
@@ -2388,7 +4783,7 @@ namespace bpkg
             // satisfies the constraint. On the other hand, it could be that
             // it's other dependent's constraints that we cannot satisfy
             // together with others. And in this case we may want some other
-            // alternative.  Consider, as an example, something like this:
+            // alternative. Consider, as an example, something like this:
             //
             // depends: libfoo >= 2.0.0 | libfoo >= 1.0.0 libbar
             //
@@ -2396,6 +4791,9 @@ namespace bpkg
             {
               if (r.repo_postpone)
               {
+                if (reeval)
+                  fail_reeval ();
+
                 postpone (nullptr); // Already inserted into postponed_repo.
                 break;
               }
@@ -2408,9 +4806,9 @@ namespace bpkg
             // Note that when we see the first satisfactory alternative, we
             // don't know yet if it is a single alternative or the first of
             // the (multiple) true alternatives (those are handled
-            // differently).  Thus, we postpone its processing until the
-            // second satisfactory alternative is encountered or the end of
-            // the alternatives list is reached.
+            // differently). Thus, we postpone its processing until the second
+            // satisfactory alternative is encountered or the end of the
+            // alternatives list is reached.
             //
             if (!first_alt)
             {
@@ -2424,15 +4822,31 @@ namespace bpkg
             // of it dependencies are reused).
             //
             auto try_select = [postponed_alts, &max_alt_index,
-                               &edas,
-                               &postpone, &select]
+                               &edas, &pkg,
+                               reeval,
+                               &trace,
+                               &postpone, &collect, &select]
                                (size_t index, precollect_result&& r)
             {
+              const auto& eda (edas[index]);
+              const dependency_alternative& da (eda.first);
+              size_t dai (eda.second);
+
               // Postpone the collection if the alternatives maximum index is
               // reached.
               //
               if (postponed_alts != nullptr && index >= max_alt_index)
               {
+                // For a dependent re-evaluation max_alt_index is expected to
+                // be max size_t.
+                //
+                assert (!reeval);
+
+                l5 ([&]{trace << "alt-postpone dependent "
+                              << pkg.available_name_version_db ()
+                              << " since max index is reached: " << index <<
+                          info << "dependency alternative: " << da;});
+
                 postpone (postponed_alts);
                 return true;
               }
@@ -2447,12 +4861,20 @@ namespace bpkg
                 //
                 assert (postponed_alts != nullptr);
 
-                select (edas[index], move (*r.builds));
+                if (!collect (da, dai, move (*r.builds)))
+                {
+                  postpone (nullptr); // Already inserted into postponed_cfgs.
+                  return true;
+                }
+
+                select (da, dai);
 
                 // Make sure no more true alternatives are selected during
-                // this function call.
+                // this function call unless we are re-evaluating a dependent.
                 //
-                max_alt_index = 0;
+                if (!reeval)
+                  max_alt_index = 0;
+
                 return true;
               }
               else
@@ -2491,7 +4913,17 @@ namespace bpkg
           {
             assert (first_alt && first_alt->second.builds);
 
-            select (edas[first_alt->first], move (*first_alt->second.builds));
+            const auto& eda (edas[first_alt->first]);
+            const dependency_alternative& da (eda.first);
+            size_t dai (eda.second);
+
+            if (!collect (da, dai, move (*first_alt->second.builds)))
+            {
+              postpone (nullptr); // Already inserted into postponed_cfgs.
+              break;
+            }
+
+            select (da, dai);
           }
 
           // If an alternative is selected, then we are done.
@@ -2500,12 +4932,16 @@ namespace bpkg
             break;
 
           // Fail or postpone the collection if no alternative is selected,
-          // unless we are in the "recreate dependency decisions" mode. In the
-          // latter case fall back to the "make dependency decisions" mode and
-          // retry.
+          // unless we are re-evaluating a dependent or are in the "recreate
+          // dependency decisions" mode. In the latter case fail for
+          // re-evaluation and fall back to the "make dependency decisions"
+          // mode and retry otherwise.
           //
           if (prereqs != nullptr)
           {
+            if (reeval)
+              fail_reeval ();
+
             prereqs = nullptr;
             continue;
           }
@@ -2516,8 +4952,8 @@ namespace bpkg
           if (alts_num == 0)
           {
             diag_record dr;
-            for (const dependency_alternative& da: edas)
-              precollect (da, das.buildtime, nullptr /* prereqs */, &dr);
+            for (const auto& da: edas)
+              precollect (da.first, das.buildtime, nullptr /* prereqs */, &dr);
 
             assert (!dr.empty ());
 
@@ -2533,6 +4969,17 @@ namespace bpkg
 
           if (postponed_alts != nullptr)
           {
+            if (verb >= 5)
+            {
+              diag_record dr (trace);
+              dr << "alt-postpone dependent "
+                 << pkg.available_name_version_db ()
+                 << " due to ambiguous alternatives";
+
+              for (const auto& da: edas)
+                dr << info << "alternative: " << da.first;
+            }
+
             postpone (postponed_alts);
             break;
           }
@@ -2543,10 +4990,10 @@ namespace bpkg
             info << "explicitly specify dependency packages to manually "
              << "select the alternative";
 
-          for (const dependency_alternative& da: edas)
+          for (const auto& da: edas)
           {
             precollect_result r (
-              precollect (da, das.buildtime, nullptr /* prereqs */));
+              precollect (da.first, das.buildtime, nullptr /* prereqs */));
 
             if (r.builds)
             {
@@ -2570,7 +5017,57 @@ namespace bpkg
           break;
       }
 
+      if (reeval)
+      {
+        if (!reevaluated)
+          fail_reeval ();
+
+        assert (postponed);
+      }
+
       dep_chain.pop_back ();
+
+      l5 ([&]{trace << (!postponed ? "end "          :
+                        reeval     ? "re-evaluated " :
+                                     "postpone ")
+                    << pkg.available_name_version_db ();});
+    }
+
+    void
+    collect_build_prerequisites (const pkg_build_options& o,
+                                 database& db,
+                                 const package_name& name,
+                                 const function<find_database_function>& fdb,
+                                 const repointed_dependents& rpt_depts,
+                                 const function<add_priv_cfg_function>& apc,
+                                 bool initial_collection,
+                                 replaced_versions& replaced_vers,
+                                 postponed_packages& postponed_repo,
+                                 postponed_packages& postponed_alts,
+                                 size_t max_alt_index,
+                                 postponed_dependencies& postponed_deps,
+                                 postponed_configurations& postponed_cfgs,
+                                 postponed_positions& postponed_poss)
+    {
+      auto mi (map_.find (db, name));
+      assert (mi != map_.end ());
+
+      build_package_refs dep_chain;
+
+      collect_build_prerequisites (o,
+                                   mi->second.package,
+                                   fdb,
+                                   rpt_depts,
+                                   apc,
+                                   initial_collection,
+                                   replaced_vers,
+                                   dep_chain,
+                                   &postponed_repo,
+                                   &postponed_alts,
+                                   max_alt_index,
+                                   postponed_deps,
+                                   postponed_cfgs,
+                                   postponed_poss);
     }
 
     // Collect the repointed dependents and their replaced prerequisites,
@@ -2585,8 +5082,12 @@ namespace bpkg
     collect_repointed_dependents (
       const pkg_build_options& o,
       const repointed_dependents& rpt_depts,
-      build_packages::postponed_packages& postponed_repo,
-      build_packages::postponed_packages& postponed_alts,
+      replaced_versions& replaced_vers,
+      postponed_packages& postponed_repo,
+      postponed_packages& postponed_alts,
+      postponed_dependencies& postponed_deps,
+      postponed_configurations& postponed_cfgs,
+      postponed_positions& postponed_poss,
       const function<find_database_function>& fdb,
       const function<add_priv_cfg_function>& apc)
     {
@@ -2619,13 +5120,13 @@ namespace bpkg
 
         // Add the prerequisite replacements as the required-by packages.
         //
-        set<config_package> required_by;
+        set<package_key> required_by;
         for (const auto& prq: rd.second)
         {
           if (prq.second) // Prerequisite replacement?
           {
-            const config_package& cp (prq.first);
-            required_by.emplace (cp.db, cp.name);
+            const package_key& pk (prq.first);
+            required_by.emplace (pk.db, pk.name);
           }
         }
 
@@ -2636,8 +5137,10 @@ namespace bpkg
           move (rp.first),
           move (rp.second),
           nullopt,                    // Dependencies.
+          nullopt,                    // Dependencies alternatives.
           nullopt,                    // Package skeleton.
           nullopt,                    // Postponed dependency alternatives.
+          false,                      // Recursive collection.
           nullopt,                    // Hold package.
           nullopt,                    // Hold version.
           {},                         // Constraints.
@@ -2661,18 +5164,62 @@ namespace bpkg
                        fdb,
                        rpt_depts,
                        apc,
+                       true /* initial_collection */,
+                       replaced_vers,
+                       postponed_cfgs,
+                       &dep_chain,
                        &postponed_repo,
                        &postponed_alts,
-                       &dep_chain);
+                       &postponed_deps,
+                       &postponed_poss);
       }
     }
 
     // Collect the package being dropped.
     //
+    // Add entry to replaced_vers and throw replace_version if the existing
+    // version needs to be dropped but this can't be done in-place (see
+    // replaced_versions for details).
+    //
     void
-    collect_drop (database& db, shared_ptr<selected_package> sp)
+    collect_drop (const pkg_build_options& options,
+                  database& db,
+                  shared_ptr<selected_package> sp,
+                  replaced_versions& replaced_vers)
     {
-      const package_name& nm (sp->name);
+      tracer trace ("collect_drop");
+
+      package_key pk (db, sp->name);
+
+      // If there is an entry for building specific version of the package
+      // (the available member is not NULL), then it wasn't created to prevent
+      // out drop (see replaced_versions for details). This rather mean that
+      // the replacement version is not being built anymore due to the plan
+      // refinement. Thus, just erase the entry in this case and continue.
+      //
+      auto vi (replaced_vers.find (pk));
+      if (vi != replaced_vers.end () && !vi->second.replaced)
+      {
+        replaced_version& v (vi->second);
+        const shared_ptr<available_package>& ap (v.available);
+
+        if (ap != nullptr)
+        {
+          if (verb >= 5)
+          {
+            bool s (v.system);
+            const version& av (s ? *ap->system_version (db) : ap->version);
+
+            l5 ([&]{trace << "erase version replacement for "
+                          << package_string (ap->id.name, av, s) << db;});
+          }
+
+          replaced_vers.erase (vi);
+          vi = replaced_vers.end (); // Keep it valid for the below check.
+        }
+        else
+          v.replaced = true;
+      }
 
       build_package p {
         build_package::drop,
@@ -2681,8 +5228,10 @@ namespace bpkg
         nullptr,
         nullptr,
         nullopt,    // Dependencies.
+        nullopt,    // Dependencies alternatives.
         nullopt,    // Package skeleton.
         nullopt,    // Postponed dependency alternatives.
+        false,      // Recursive collection.
         nullopt,    // Hold package.
         nullopt,    // Hold version.
         {},         // Constraints.
@@ -2697,20 +5246,55 @@ namespace bpkg
         false,      // Required by dependents.
         0};         // State flags.
 
-      auto i (map_.find (db, nm));
+      auto i (map_.find (pk));
 
       if (i != map_.end ())
       {
         build_package& bp (i->second.package);
 
+        if (bp.available != nullptr)
+        {
+          // Similar to the version replacement in collect_build(), see if
+          // in-place drop is possible (no dependencies, etc) and set scratch
+          // to false if that's the case.
+          //
+          bool scratch (true);
+
+          // While checking if the package has any dependencies skip the
+          // toolchain build-time dependencies since they should be quite
+          // common.
+          //
+          if (!has_dependencies (options, bp.available->dependencies))
+            scratch = false;
+
+          l5 ([&]{trace << bp.available_name_version_db ()
+                        << " package version needs to be replaced "
+                        << (!scratch ? "in-place " : "") << "with drop";});
+
+          if (scratch)
+          {
+            if (vi != replaced_vers.end ())
+              vi->second = replaced_version ();
+            else
+              replaced_vers.emplace (move (pk), replaced_version ());
+
+            throw replace_version ();
+          }
+        }
+
         // Overwrite the existing (possibly pre-entered, adjustment, or
         // repoint) entry.
         //
+        l4 ([&]{trace << "overwrite " << pk;});
+
         bp = move (p);
       }
       else
-        map_.emplace (config_package {db, nm},
-                      data_type {end (), move (p)});
+      {
+        l4 ([&]{trace << "add " << pk;});
+
+        map_.emplace (move (pk), data_type {end (), move (p)});
+      }
     }
 
     // Collect the package being unheld.
@@ -2734,21 +5318,23 @@ namespace bpkg
           sp,
           nullptr,
           nullptr,
-          nullopt,    // Dependencies.
-          nullopt,    // Package skeleton.
-          nullopt,    // Postponed dependency alternatives.
-          nullopt,    // Hold package.
-          nullopt,    // Hold version.
-          {},         // Constraints.
-          false,      // System package.
-          false,      // Keep output directory.
-          false,      // Disfigure (from-scratch reconf).
-          false,      // Configure-only.
-          nullopt,    // Checkout root.
-          false,      // Checkout purge.
-          strings (), // Configuration variables.
-          {},         // Required by.
-          false,      // Required by dependents.
+          nullopt,       // Dependencies.
+          nullopt,       // Dependencies alternatives.
+          nullopt,       // Package skeleton.
+          nullopt,       // Postponed dependency alternatives.
+          false,         // Recursive collection.
+          nullopt,       // Hold package.
+          nullopt,       // Hold version.
+          {},            // Constraints.
+          sp->system (),
+          false,         // Keep output directory.
+          false,         // Disfigure (from-scratch reconf).
+          false,         // Configure-only.
+          nullopt,       // Checkout root.
+          false,         // Checkout purge.
+          strings (),    // Configuration variables.
+          {},            // Required by.
+          false,         // Required by dependents.
           build_package::adjust_unhold};
 
         p.merge (move (bp));
@@ -2759,46 +5345,823 @@ namespace bpkg
     }
 
     void
-    collect_build_prerequisites (const pkg_build_options& o,
-                                 database& db,
-                                 const package_name& name,
-                                 postponed_packages& postponed_repo,
-                                 postponed_packages& postponed_alts,
-                                 size_t max_alt_index,
-                                 const function<find_database_function>& fdb,
-                                 const repointed_dependents& rpt_depts,
-                                 const function<add_priv_cfg_function>& apc)
-    {
-      auto mi (map_.find (db, name));
-      assert (mi != map_.end ());
-
-      build_package_refs dep_chain;
-
-      collect_build_prerequisites (o,
-                                   mi->second.package,
-                                   fdb,
-                                   rpt_depts,
-                                   apc,
-                                   &postponed_repo,
-                                   &postponed_alts,
-                                   max_alt_index,
-                                   dep_chain);
-    }
-
-    void
     collect_build_postponed (const pkg_build_options& o,
+                             replaced_versions& replaced_vers,
                              postponed_packages& postponed_repo,
                              postponed_packages& postponed_alts,
+                             postponed_dependencies& postponed_deps,
+                             postponed_configurations& postponed_cfgs,
+                             strings& postponed_cfgs_history,
+                             postponed_positions& postponed_poss,
                              const function<find_database_function>& fdb,
                              const repointed_dependents& rpt_depts,
-                             const function<add_priv_cfg_function>& apc)
+                             const function<add_priv_cfg_function>& apc,
+                             postponed_configuration* pcfg = nullptr)
     {
+      // Snapshot of the package builds collection state.
+      //
+      // Note: should not include postponed_cfgs_history.
+      //
+      class snapshot
+      {
+      public:
+        snapshot (const build_packages& pkgs,
+                  const postponed_packages& postponed_repo,
+                  const postponed_packages& postponed_alts,
+                  const postponed_dependencies& postponed_deps,
+                  const postponed_configurations& postponed_cfgs)
+            : pkgs_ (pkgs),
+              postponed_deps_ (postponed_deps),
+              postponed_cfgs_ (postponed_cfgs)
+        {
+          auto save = [] (vector<package_key>& d,
+                          const postponed_packages& s)
+          {
+            d.reserve (s.size ());
+
+            for (const build_package* p: s)
+              d.emplace_back (p->db, p->name ());
+          };
+
+          save (postponed_repo_, postponed_repo);
+          save (postponed_alts_, postponed_alts);
+        }
+
+        void
+        restore (build_packages& pkgs,
+                 postponed_packages& postponed_repo,
+                 postponed_packages& postponed_alts,
+                 postponed_dependencies& postponed_deps,
+                 postponed_configurations& postponed_cfgs)
+        {
+          pkgs           = move (pkgs_);
+          postponed_cfgs = move (postponed_cfgs_);
+          postponed_deps = move (postponed_deps_);
+
+          auto restore = [&pkgs] (postponed_packages& d,
+                                  const vector<package_key>& s)
+          {
+            d.clear ();
+
+            for (const package_key& p: s)
+            {
+              build_package* b (pkgs.entered_build (p));
+              assert (b != nullptr);
+              d.insert (b);
+            }
+          };
+
+          restore (postponed_repo, postponed_repo_);
+          restore (postponed_alts, postponed_alts_);
+        }
+
+      private:
+        // Note: try to use vectors instead of sets for storage to save
+        //       memory. We could probably optimize this some more if
+        //       necessary (there are still sets/maps inside).
+        //
+        build_packages           pkgs_;
+        vector<package_key>      postponed_repo_;
+        vector<package_key>      postponed_alts_;
+        postponed_dependencies   postponed_deps_;
+        postponed_configurations postponed_cfgs_;
+      };
+
+      // This exception is thrown if negotiation of the current cluster needs
+      // to be skipped until later. This is normally required if this cluster
+      // contains some existing dependent which needs to be re-evaluated to a
+      // dependency position greater than some other not yet negotiated
+      // cluster will re-evaluate this dependent to. Sometimes this another
+      // cluster yet needs to be created in which case the exception carries
+      // the information required for that (see the postponed_position's
+      // replace flag for details).
+      //
+      struct skip_configuration
+      {
+        optional<existing_dependent> dependent;
+        pair<size_t, size_t> new_position;
+
+        skip_configuration () = default;
+
+        skip_configuration (existing_dependent&& d, pair<size_t, size_t> n)
+            : dependent (move (d)), new_position (n) {}
+      };
+
+      size_t depth (pcfg != nullptr ? pcfg->depth : 0);
+
+      string t ("collect_build_postponed (" + to_string (depth) + ")");
+      tracer trace (t.c_str ());
+
+      string trace_suffix (verb >= 5 && pcfg != nullptr
+                           ? " " + pcfg->string ()
+                           : "");
+
+      l5 ([&]{trace << "begin" << trace_suffix;});
+
+      if (pcfg != nullptr)
+      {
+        // This is what we refer to as the "initial negotiation" where we
+        // negotiate the configuration of dependents that could be postponed.
+        // Those that could not we "up-negotiate" in the collect() lambda of
+        // collect_build_prerequisites().
+        //
+        using packages = postponed_configuration::packages;
+
+        assert (!pcfg->negotiated);
+
+        // Re-evaluate existing dependents with configuration clause for
+        // dependencies in this configuration cluster up to these
+        // dependencies. Omit dependents which are already being built or
+        // dropped. Note that these dependents, potentially with additional
+        // dependencies, will be added to this cluster with the `existing`
+        // flag as a part of the dependents' re-evaluation (see the collect
+        // lambda in collect_build_prerequisites() for details).
+        //
+        // After being re-evaluated the existing dependents are recursively
+        // collected in the same way as the new dependents.
+        //
+        {
+          // Map existing dependents to the dependencies they apply a
+          // configuration to. Also, collect the information which is required
+          // for a dependent re-evaluation and its subsequent recursive
+          // collection (selected package, etc).
+          //
+          // As mentioned earlier, we may end up adding additional
+          // dependencies to pcfg->dependencies which in turn may have
+          // additional existing dependents which we need to process. Feels
+          // like doing this iteratively is the best option.
+          //
+          // Note that we need to make sure we don't re-process the same
+          // existing dependents.
+          //
+          struct existing_dependent_ex: existing_dependent
+          {
+            packages dependencies;
+            bool     reevaluated = false;
+
+            existing_dependent_ex (existing_dependent&& ed)
+                : existing_dependent (move (ed)) {}
+          };
+          map<package_key, existing_dependent_ex> dependents;
+
+          const packages& deps (pcfg->dependencies);
+
+          // Note that the below collect_build_prerequisites() call can only
+          // add new dependencies to the end of the cluster's dependencies
+          // list. Thus on each iteration we will only add existing dependents
+          // of unprocessed/new dependencies. We will also skip the already
+          // re-evaluated existing dependents.
+          //
+          for (size_t i (0); i != deps.size (); )
+          {
+            size_t n (dependents.size ());
+
+            for (; i != deps.size (); ++i)
+            {
+              // Note: this reference is only used while deps is unchanged.
+              //
+              const package_key& p (deps[i]);
+
+              // If the dependent is being built, then check if it was
+              // re-evaluated to the position greater than the dependency
+              // position. Return true if that's the case, so this package is
+              // added to the resulting list and we can handle this situation.
+              //
+              // Note that we rely on "small function object" optimization
+              // here.
+              //
+              const function<verify_dependent_build_function> verify (
+                [&postponed_cfgs, pcfg]
+                (const package_key& pk, pair<size_t, size_t> pos)
+                {
+                  for (const postponed_configuration& cfg: postponed_cfgs)
+                  {
+                    if (&cfg == pcfg || cfg.negotiated)
+                    {
+                      if (const pair<size_t, size_t>* p =
+                          cfg.existing_dependent_position (pk))
+                      {
+                        if (p->first > pos.first)
+                          return true;
+                      }
+                    }
+                  }
+
+                  return false;
+                });
+
+              for (existing_dependent& ed:
+                     query_existing_dependents (trace,
+                                                p.db,
+                                                p.name,
+                                                replaced_vers,
+                                                rpt_depts,
+                                                verify))
+              {
+                package_key pk (ed.db, ed.selected->name);
+
+                // If this dependent is present in postponed_deps, then it
+                // means someone depends on it with configuration and it's no
+                // longer considered an existing dependent (it will be
+                // reconfigured). However, this fact may not be reflected yet.
+                // And it can actually turn out bogus.
+                //
+                auto pi (postponed_deps.find (pk));
+                if (pi != postponed_deps.end ())
+                {
+                  l5 ([&]{trace << "skip dep-postponed existing dependent "
+                                << pk << " of dependency " << p;});
+
+                  // Note that here we would re-evaluate the existing dependent
+                  // without specifying any configuration for it.
+                  //
+                  pi->second.wout_config = true;
+
+                  continue;
+                }
+
+                auto i (dependents.find (pk));
+                size_t di (ed.dependency_position.first);
+
+                // Skip re-evaluated dependent if the dependency index is
+                // greater than the one we have already re-evaluated to. If it
+                // is earlier, then add the entry to postponed_poss and throw
+                // postpone_position to recollect from scratch. Note that this
+                // entry in postponed_poss is with replacement.
+                //
+                if (i != dependents.end () && i->second.reevaluated)
+                {
+                  size_t ci (i->second.dependency_position.first);
+
+                  if (di > ci)
+                    continue;
+
+                  // The newly-introduced dependency must belong to the
+                  // depends value other then the one we have re-evaluated to.
+                  //
+                  assert (di < ci);
+
+                  postponed_position pp (ed.dependency_position,
+                                         true /* replace */);
+
+                  auto p (postponed_poss.emplace (pk, pp));
+
+                  if (!p.second)
+                  {
+                    assert (p.first->second > pp);
+                    p.first->second = pp;
+                  }
+
+                  l5 ([&]{trace << "cannot re-evaluate dependent "
+                                << pk << " to dependency index " << di
+                                << " since it is already re-evaluated to "
+                                << "greater index " << ci << " in " << *pcfg
+                                << ", throwing postpone_position";});
+
+                  throw postpone_position ();
+                }
+
+                // If the existing dependent is not in the map yet, then add
+                // it. Otherwise, if the dependency position is greater than
+                // that one in the existing map entry then skip it (this
+                // position will be up-negotiated, if it's still present).
+                // Otherwise, if the position is less then overwrite the
+                // existing entry. Otherwise (the position is equal), just
+                // add the dependency to the existing entry.
+                //
+                // Note that we want to re-evaluate the dependent up to the
+                // earliest dependency position and continue with the regular
+                // prerequisites collection (as we do for new dependents)
+                // afterwards.
+                //
+                if (i == dependents.end ())
+                {
+                  i = dependents.emplace (
+                    move (pk), existing_dependent_ex (move (ed))).first;
+                }
+                else
+                {
+                  size_t ci (i->second.dependency_position.first);
+
+                  if (ci < di)
+                    continue;
+                  else if (ci > di)
+                    i->second = existing_dependent_ex (move (ed));
+                  //else if (ci == di)
+                  //  ;
+                }
+
+                i->second.dependencies.push_back (p);
+              }
+            }
+
+            // Re-evaluate the newly added existing dependents, if any.
+            //
+            if (dependents.size () != n)
+            {
+              l5 ([&]{trace << "re-evaluate existing dependents for " << *pcfg;});
+
+              for (auto& d: dependents)
+              {
+                existing_dependent_ex& ed (d.second);
+
+                // Skip re-evaluated.
+                //
+                if (ed.reevaluated)
+                  continue;
+
+                size_t di (ed.dependency_position.first);
+                const package_key& pk (d.first);
+
+                // Check if there is an earlier dependency position for this
+                // dependent that will be participating in a configuration
+                // negotiation and skip this cluster if that's the case. There
+                // are two places to check: postponed_poss and other clusters.
+                //
+                auto pi (postponed_poss.find (pk));
+                if (pi != postponed_poss.end () && pi->second.first < di)
+                {
+                  l5 ([&]{trace << "pos-postpone existing dependent "
+                                << pk << " re-evaluation to dependency "
+                                << "index " << di << " due to recorded index "
+                                << pi->second.first << ", skipping " << *pcfg;});
+
+                  pi->second.skipped = true;
+
+                  // If requested, override the first encountered non-replace
+                  // position to replace (see below for details).
+                  //
+                  if (!pi->second.replace && postponed_poss.replace)
+                  {
+                    pi->second.replace = true;
+                    postponed_poss.replace = false;
+                  }
+
+                  if (pi->second.replace)
+                    throw skip_configuration (move (ed), pi->second);
+                  else
+                    throw skip_configuration ();
+                }
+
+                // The other clusters check is a bit more complicated: if the
+                // other cluster (with the earlier position) is not yet
+                // negotiated, then we skip. Otherwise, we have to add an
+                // entry to postponed_poss and backtrack.
+                //
+                bool skip (false);
+                for (const postponed_configuration& cfg: postponed_cfgs)
+                {
+                  // Skip the current cluster.
+                  //
+                  if (&cfg == pcfg)
+                    continue;
+
+                  if (const pair<size_t, size_t>* p =
+                      cfg.existing_dependent_position (pk))
+                  {
+                    size_t ei (p->first); // Other position.
+
+                    if (!cfg.negotiated)
+                    {
+                      if (ei < di)
+                      {
+                        l5 ([&]{trace << "cannot re-evaluate dependent "
+                                      << pk << " to dependency index " << di
+                                      << " due to earlier dependency index "
+                                      << ei << " in " << cfg << ", skipping "
+                                      << *pcfg;});
+
+                        skip = true;
+                      }
+                    }
+                    else
+                    {
+                      // If this were not the case, then this dependent
+                      // wouldn't have been considered as an existing by
+                      // query_existing_dependents() since as it is (being)
+                      // negotiated then it is already re-evaluated and so is
+                      // being built (see the verify lambda above).
+                      //
+                      assert (ei > di);
+
+                      // Feels like there cannot be an earlier position.
+                      //
+                      postponed_position pp (ed.dependency_position,
+                                             false /* replace */);
+
+                      auto p (postponed_poss.emplace (pk, pp));
+                      if (!p.second)
+                      {
+                        assert (p.first->second > pp);
+                        p.first->second = pp;
+                      }
+
+                      l5 ([&]{trace << "cannot re-evaluate dependent "
+                                    << pk << " to dependency index " << di
+                                    << " due to greater dependency "
+                                    << "index " << ei << " in " << cfg
+                                    << ", throwing postpone_position";});
+
+                      throw postpone_position ();
+                    }
+                  }
+                }
+
+                if (skip)
+                  throw skip_configuration ();
+
+                // Finally, re-evaluate the dependent.
+                //
+                packages& ds (ed.dependencies);
+
+                pair<shared_ptr<available_package>,
+                     lazy_shared_ptr<repository_fragment>> rp (
+                       find_available_fragment (o, pk.db, ed.selected));
+
+                build_package p {
+                  build_package::build,
+                  pk.db,
+                  move (ed.selected),
+                  move (rp.first),
+                  move (rp.second),
+                  nullopt,                    // Dependencies.
+                  nullopt,                    // Dependencies alternatives.
+                  nullopt,                    // Package skeleton.
+                  nullopt,                    // Postponed dependency alternatives.
+                  false,                      // Recursive collection.
+                  nullopt,                    // Hold package.
+                  nullopt,                    // Hold version.
+                  {},                         // Constraints.
+                  false,                      // System.
+                  false,                      // Keep output directory.
+                  false,                      // Disfigure (from-scratch reconf).
+                  false,                      // Configure-only.
+                  nullopt,                    // Checkout root.
+                  false,                      // Checkout purge.
+                  strings (),                 // Configuration variables.
+                  set<package_key> (          // Required by (dependency).
+                    ds.begin (), ds.end ()),
+                  false,                      // Required by dependents.
+                  build_package::adjust_reconfigure};
+
+                // Note: not recursive.
+                //
+                collect_build (o,
+                               move (p),
+                               fdb,
+                               rpt_depts,
+                               apc,
+                               false /* initial_collection */,
+                               replaced_vers,
+                               postponed_cfgs);
+
+                build_package* b (entered_build (pk));
+                assert (b != nullptr);
+
+                // Re-evaluate up to the earliest position.
+                //
+                assert (ed.dependency_position.first != 0);
+
+                build_package_refs dep_chain;
+                collect_build_prerequisites (o,
+                                             *b,
+                                             fdb,
+                                             rpt_depts,
+                                             apc,
+                                             false /* initial_collection */,
+                                             replaced_vers,
+                                             dep_chain,
+                                             &postponed_repo,
+                                             &postponed_alts,
+                                             numeric_limits<size_t>::max (),
+                                             postponed_deps,
+                                             postponed_cfgs,
+                                             postponed_poss,
+                                             ed.dependency_position);
+
+                ed.reevaluated = true;
+
+                if (pi != postponed_poss.end ())
+                {
+                  // Otherwise we should have thrown skip_configuration above.
+                  //
+                  assert (di <= pi->second.first);
+
+                  pi->second.reevaluated = true;
+                }
+              }
+            }
+          }
+        }
+
+        l5 ([&]{trace << "cfg-negotiate begin " << *pcfg;});
+
+        // Negotiate the configuration.
+        //
+        // The overall plan is as follows: continue refining the configuration
+        // until there are no more changes by giving each dependent a chance
+        // to make further adjustments.
+        //
+        for (auto b (pcfg->dependents.begin ()),
+               i (b),
+               e (pcfg->dependents.end ()); i != e; )
+        {
+          // Resolve package skeletons for the dependent and its dependencies.
+          //
+          // For the dependent, the skeleton should be already there (since we
+          // should have started recursively collecting it). For a dependency,
+          // it should not already be there (since we haven't yet started
+          // recursively collecting it). But we could be re-resolving the same
+          // dependency multiple times.
+          //
+          package_skeleton* dept;
+          {
+            build_package* b (entered_build (i->first));
+            assert (b != nullptr && b->skeleton);
+            dept = &*b->skeleton;
+          }
+
+          pair<size_t, size_t> pos;
+          small_vector<reference_wrapper<package_skeleton>, 1> depcs;
+          {
+            // A non-negotiated cluster must only have one depends position
+            // for each dependent.
+            //
+            assert (i->second.dependencies.size () == 1);
+
+            const postponed_configuration::dependency& ds (
+              i->second.dependencies.front ());
+
+            pos = ds.position;
+
+            depcs.reserve (ds.size ());
+            for (const package_key& pk: ds)
+            {
+              build_package* b (entered_build (pk));
+              assert (b != nullptr);
+
+              depcs.push_back (b->skeleton
+                               ? *b->skeleton
+                               : b->init_skeleton (o /* options */));
+            }
+          }
+
+          if (negotiate_configuration (
+                pcfg->dependency_configurations, *dept, pos, depcs))
+          {
+            if (i != b)
+            {
+              i = b; // Restart from the beginning.
+              continue;
+            }
+          }
+
+          ++i;
+        }
+
+        // Being negotiated (so can only be up-negotiated).
+        //
+        pcfg->negotiated = false;
+
+        // Note that we can be adding new packages to the being negotiated
+        // cluster by calling collect_build_prerequisites() for its
+        // dependencies and dependents. Thus, we need to stash the current
+        // list of dependencies and dependents and iterate over them.
+        //
+        // Note that whomever is adding new packages is expected to process
+        // them (they may also process existing packages, which we are
+        // prepared to ignore).
+        //
+        packages dependencies (pcfg->dependencies);
+
+        packages dependents;
+        dependents.reserve (pcfg->dependents.size ());
+
+        for (const auto& p: pcfg->dependents)
+          dependents.push_back (p.first);
+
+        // Process dependencies recursively with this config.
+        //
+        // Note that there could be inter-dependecies between these packages,
+        // which means the configuration can only be up-negotiated.
+        //
+        l5 ([&]{trace << "recursively collect cfg-negotiated dependencies";});
+
+        for (const package_key& p: dependencies)
+        {
+          build_package* b (entered_build (p));
+          assert (b != nullptr);
+
+          // Reconfigure the configured dependencies.
+          //
+          // Note that potentially this can be an overkill if the dependency
+          // configuration doesn't really change. Later we can implement some
+          // precise detection for that using configuration checksum or
+          // similar.
+          //
+          // Also note that for configured dependents which belong to the
+          // configuration cluster this flag is already set (see above).
+          //
+          if (b->selected != nullptr &&
+              b->selected->state == package_state::configured)
+            b->flags |= build_package::adjust_reconfigure;
+
+          // Skip the dependencies which are already collected recursively.
+          //
+          if (!b->recursive_collection)
+          {
+            // Verify and set the dependent configuration for this dependency.
+            //
+            // Note: see similar code for the up-negotiation case.
+            //
+            {
+              assert (b->skeleton); // Should have been init'ed above.
+
+              const package_configuration& pc (
+                pcfg->dependency_configurations[p]);
+
+              // Skip the verification if this is a system package
+              // without skeleton info.
+              //
+              pair<bool, string> pr (b->skeleton->available != nullptr
+                                     ? b->skeleton->verify_sensible (pc)
+                                     : make_pair (true, string ()));
+
+              if (!pr.first)
+              {
+                // Note that the diagnostics from the dependency will most
+                // likely be in the "error ..." form (potentially with
+                // additional info lines) and by printing it with a two-space
+                // indentation we make it "fit" into our diag record.
+                //
+                diag_record dr (fail);
+                dr << "unable to negotiate sensible configuration for "
+                   << "dependency " << p << '\n'
+                   << "  " << pr.second;
+
+                dr << info << "negotiated configuration:\n";
+                pc.print (dr, "    "); // Note 4 spaces since in nested info.
+              }
+
+              b->skeleton->dependent_config (pc);
+            }
+
+            build_package_refs dep_chain;
+            collect_build_prerequisites (o,
+                                         *b,
+                                         fdb,
+                                         rpt_depts,
+                                         apc,
+                                         false /* initial_collection */,
+                                         replaced_vers,
+                                         dep_chain,
+                                         &postponed_repo,
+                                         &postponed_alts,
+                                         0 /* max_alt_index */,
+                                         postponed_deps,
+                                         postponed_cfgs,
+                                         postponed_poss);
+          }
+          else
+            l5 ([&]{trace << "dependency " << b->available_name_version_db ()
+                          << " is already (being) recursively collected, "
+                          << "skipping";});
+        }
+
+        // Continue processing dependents with this config.
+        //
+        l5 ([&]{trace << "recursively collect cfg-negotiated dependents";});
+
+        for (const auto& p: dependents)
+        {
+          // Select the dependency alternative for which configuration has
+          // been negotiated and collect this dependent starting from the next
+          // depends value.
+          //
+          build_package* b (entered_build (p));
+
+          // We should have been started recursively collecting the dependent
+          // and it should have been postponed.
+          //
+          assert (b != nullptr            &&
+                  b->available != nullptr &&
+                  b->dependencies         &&
+                  b->skeleton             &&
+                  b->postponed_dependency_alternatives);
+
+          // Select the dependency alternative (evaluate reflect if present,
+          // etc) and position to the next depends value (see
+          // collect_build_prerequisites() for details).
+          //
+          {
+            const bpkg::dependencies& deps  (b->available->dependencies);
+            bpkg::dependencies&       sdeps (*b->dependencies);
+            vector<size_t>&           salts (*b->alternatives);
+
+            size_t di (sdeps.size ());
+
+            // Skip the dependent if it has been already collected as some
+            // package's dependency or some such.
+            //
+            if (di == deps.size ())
+            {
+              l5 ([&]{trace << "dependent " << b->available_name_version_db ()
+                            << " is already recursively collected, skipping";});
+
+              continue;
+            }
+
+            l5 ([&]{trace << "select cfg-negotiated dependency alternative "
+                          << "for dependent "
+                          << b->available_name_version_db ();});
+
+            // Find the postponed dependency alternative.
+            //
+            auto i (pcfg->dependents.find (p));
+
+            assert (i != pcfg->dependents.end () &&
+                    i->second.dependencies.size () == 1);
+
+            pair<size_t, size_t> dp (i->second.dependencies[0].position);
+            assert (dp.first == sdeps.size () + 1);
+
+            build_package::dependency_alternatives_refs pdas (
+              move (*b->postponed_dependency_alternatives));
+
+            b->postponed_dependency_alternatives = nullopt;
+
+            auto j (find_if (pdas.begin (), pdas.end (),
+                             [&dp] (const auto& da)
+                             {
+                               return da.second + 1 == dp.second;
+                             }));
+
+            assert (j != pdas.end ());
+
+            const dependency_alternative& da (j->first);
+            size_t dai (j->second);
+
+            // Select the dependency alternative and position to the next
+            // depends value.
+            //
+            const dependency_alternatives_ex& das (deps[di]);
+            dependency_alternatives_ex sdas (das.buildtime, das.comment);
+
+            sdas.emplace_back (nullopt /* enable */,
+                               nullopt /* reflect */,
+                               da.prefer,
+                               da.accept,
+                               da.require,
+                               da /* dependencies */);
+
+            sdeps.push_back (move (sdas));
+            salts.push_back (dai);
+
+            // Evaluate reflect, if present.
+            //
+            if (da.reflect)
+              b->skeleton->evaluate_reflect (*da.reflect, make_pair (di, dai));
+          }
+
+          // Continue recursively collecting the dependent.
+          //
+          build_package_refs dep_chain;
+
+          collect_build_prerequisites (
+            o,
+            *b,
+            fdb,
+            rpt_depts,
+            apc,
+            false /* initial_collection */,
+            replaced_vers,
+            dep_chain,
+            &postponed_repo,
+            &postponed_alts,
+            0 /* max_alt_index */,
+            postponed_deps,
+            postponed_cfgs,
+            postponed_poss);
+        }
+
+        // Negotiated (so can only be rolled back).
+        //
+        pcfg->negotiated = true;
+
+        l5 ([&]{trace << "cfg-negotiate end " << *pcfg;});
+
+        // Fall through (to start another iteration of the below loop).
+      }
+
       // Try collecting postponed packages for as long as we are making
       // progress.
       //
       vector<build_package*> spas; // Reuse.
 
-      for (bool prog (!postponed_repo.empty () || !postponed_alts.empty ());
+      for (bool prog (!postponed_repo.empty ()      ||
+                      !postponed_cfgs.negotiated () ||
+                      !postponed_alts.empty ()      ||
+                      postponed_deps.has_bogus ());
            prog; )
       {
         postponed_packages prs;
@@ -2808,6 +6171,9 @@ namespace bpkg
         //
         for (build_package* p: postponed_repo)
         {
+          l5 ([&]{trace << "collect rep-postponed "
+                        << p->available_name_version_db ();});
+
           build_package_refs dep_chain;
 
           collect_build_prerequisites (o,
@@ -2815,13 +6181,18 @@ namespace bpkg
                                        fdb,
                                        rpt_depts,
                                        apc,
+                                       false /* initial_collection */,
+                                       replaced_vers,
+                                       dep_chain,
                                        &prs,
                                        &pas,
                                        0 /* max_alt_index */,
-                                       dep_chain);
+                                       postponed_deps,
+                                       postponed_cfgs,
+                                       postponed_poss);
         }
 
-        // Save the potential new dependency alternative-related postpones.
+        // Save the potential new dependency alternative-related postponements.
         //
         postponed_alts.insert (pas.begin (), pas.end ());
 
@@ -2834,12 +6205,260 @@ namespace bpkg
         }
 
         // Now, as there is no more progress made in collecting repository-
-        // related postpones, try to collect the dependency alternative-
-        // related postpones.
+        // related postponements, collect the dependency configuration-related
+        // postponements.
+        //
+        // Note that we do it before alternatives since configurations we do
+        // perfectly (via backtracking) while alternatives -- heuristically.
+        //
+        // Note that since the potential snapshot restore replaces all the
+        // list entries we cannot iterate using the iterator here. Also note
+        // that the list size may change during iterating.
+        //
+        for (size_t ci (0); ci != postponed_cfgs.size (); ++ci)
+        {
+          postponed_configuration* pc (&postponed_cfgs[ci]);
+
+          // Find the next configuration to try to negotiate, skipping the
+          // already negotiated ones.
+          //
+          if (pc->negotiated)
+            continue;
+
+          size_t pcd (depth + 1);
+          pc->depth = pcd;
+
+          // Either return or retry the same cluster or skip this cluster and
+          // proceed to the next one.
+          //
+          for (;;)
+          {
+            // First assume we can negotiate this configuration rolling back
+            // if this doesn't pan out.
+            //
+            snapshot s (*this,
+                        postponed_repo,
+                        postponed_alts,
+                        postponed_deps,
+                        postponed_cfgs);
+
+            try
+            {
+              collect_build_postponed (o,
+                                       replaced_vers,
+                                       postponed_repo,
+                                       postponed_alts,
+                                       postponed_deps,
+                                       postponed_cfgs,
+                                       postponed_cfgs_history,
+                                       postponed_poss,
+                                       fdb,
+                                       rpt_depts,
+                                       apc,
+                                       pc);
+
+              // If collect() returns (instead of throwing), this means it
+              // processed everything that was postponed.
+              //
+              assert (postponed_repo.empty ()      &&
+                      postponed_cfgs.negotiated () &&
+                      postponed_alts.empty ()      &&
+                      !postponed_deps.has_bogus ());
+
+              l5 ([&]{trace << "end" << trace_suffix;});
+
+              return;
+            }
+            catch (skip_configuration& e)
+            {
+              // Restore the state from snapshot.
+              //
+              // Note: postponed_cfgs is re-assigned.
+              //
+              s.restore (*this,
+                         postponed_repo,
+                         postponed_alts,
+                         postponed_deps,
+                         postponed_cfgs);
+
+              pc = &postponed_cfgs[ci];
+
+              // Note that in this case we keep the accumulated configuration,
+              // if any.
+
+              pc->depth = 0;
+
+              // If requested, "replace" the "later" dependent-dependency
+              // cluster with an earlier.
+              //
+              if (e.dependent)
+              {
+                existing_dependent& ed (*e.dependent);
+                pair<size_t, size_t> pos (e.new_position);
+
+                const build_package* bp (
+                  replace_existing_dependent_dependency (
+                    trace,
+                    o,
+                    ed, // Note: modified.
+                    pos,
+                    fdb,
+                    rpt_depts,
+                    apc,
+                    false /* initial_collection */,
+                    replaced_vers,
+                    postponed_cfgs));
+
+                postponed_cfgs.add (package_key (ed.db, ed.selected->name),
+                                    pos,
+                                    package_key (bp->db, bp->selected->name));
+              }
+
+              l5 ([&]{trace << "postpone cfg-negotiation of " << *pc;});
+
+              break;
+            }
+            catch (const retry_configuration& e)
+            {
+              // If this is not "our problem", then keep looking.
+              //
+              if (e.depth != pcd)
+                throw;
+
+              package_configurations cfgs (
+                move (pc->dependency_configurations));
+
+              // Restore the state from snapshot.
+              //
+              // Note: postponed_cfgs is re-assigned.
+              //
+              s.restore (*this,
+                         postponed_repo,
+                         postponed_alts,
+                         postponed_deps,
+                         postponed_cfgs);
+
+              pc = &postponed_cfgs[ci];
+
+              l5 ([&]{trace << "cfg-negotiation of " << *pc << " failed due "
+                            << "to dependent " << e.dependent << ", refining "
+                            << "configuration";});
+
+              // Copy over the configuration for further refinement.
+              //
+              // Note that there is also a possibility of ending up with
+              // "bogus" configuration variables that were set by a dependent
+              // during up-negotiation but, due to changes to the overall
+              // configuration, such a dependent were never re-visited.
+              //
+              // The way we are going to deal with this is by detecting such
+              // bogus variables based on the confirmed flag, cleaning them
+              // out, and doing another retry. Here we clear the confirmed
+              // flag and the detection happens in collect_build_postponed()
+              // after we have processed everything postponed (since that's
+              // the only time we can be certain there could no longer be a
+              // re-visit).
+              //
+              for (package_configuration& cfg: cfgs)
+                for (config_variable_value& v: cfg)
+                  if (v.dependent)
+                    v.confirmed = false;
+
+              pc->dependency_configurations = move (cfgs);
+            }
+            catch (merge_configuration& e)
+            {
+              // If this is not "our problem", then keep looking.
+              //
+              if (e.depth != pcd)
+                throw;
+
+              postponed_configuration shadow (move (*pc));
+
+              // Restore the state from snapshot.
+              //
+              // Note: postponed_cfgs is re-assigned.
+              //
+              s.restore (*this,
+                         postponed_repo,
+                         postponed_alts,
+                         postponed_deps,
+                         postponed_cfgs);
+
+              pc = &postponed_cfgs[ci];
+
+              assert (!pc->negotiated);
+
+              // Drop any accumulated configuration (which could be carried
+              // over from retry_configuration logic).
+              //
+              pc->dependency_configurations.clear ();
+
+              l5 ([&]{trace << "cfg-negotiation of " << *pc << " failed due "
+                            << "to non-negotiated clusters, force-merging "
+                            << "based on shadow cluster " << shadow;});
+
+              // Pre-merge into this cluster those non-negotiated clusters
+              // which were merged into the shadow cluster.
+              //
+              for (size_t id: shadow.merged_ids)
+              {
+                postponed_configuration* c (postponed_cfgs.find (id));
+
+                if (c != nullptr)
+                {
+                  // Otherwise we would be handling the exception in the
+                  // higher stack frame.
+                  //
+                  assert (!c->negotiated);
+
+                  l5 ([&]{trace << "force-merge " << *c << " into " << *pc;});
+
+                  pc->merge (move (*c));
+
+                  // Mark configuration as the one being merged from for
+                  // subsequent erasing from the list.
+                  //
+                  c->dependencies.clear ();
+                }
+              }
+
+              // Erase clusters which we have merged from. Also re-translate
+              // the current cluster address into index which may change as a
+              // result of the merge.
+              //
+              auto i (postponed_cfgs.begin ());
+              auto j (postponed_cfgs.before_begin ()); // Precedes iterator i.
+
+              for (size_t k (0); i != postponed_cfgs.end (); )
+              {
+                if (!i->dependencies.empty ())
+                {
+                  if (&*i == pc)
+                    ci = k;
+
+                  ++i;
+                  ++j;
+                  ++k;
+                }
+                else
+                  i = postponed_cfgs.erase_after (j);
+              }
+
+              pc->set_shadow_cluster (move (shadow));
+            }
+          }
+        }
+
+        // Note that we only get here if we didn't make any progress on the
+        // previous loop (the only "progress" path ends with return).
+
+        // Now, try to collect the dependency alternative-related
+        // postponements.
         //
         if (!postponed_alts.empty ())
         {
-          // Sort the postpones in the unprocessed dependencies count
+          // Sort the postponments in the unprocessed dependencies count
           // descending order.
           //
           // The idea here is to preferably handle those postponed packages
@@ -2901,19 +6520,28 @@ namespace bpkg
 
               build_package_refs dep_chain;
 
+              l5 ([&]{trace << "index " << i << " collect alt-postponed "
+                            << p->available_name_version_db ();});
+
               collect_build_prerequisites (o,
                                            *p,
                                            fdb,
                                            rpt_depts,
                                            apc,
+                                           false /* initial_collection */,
+                                           replaced_vers,
+                                           dep_chain,
                                            &prs,
                                            &pas,
                                            i,
-                                           dep_chain);
+                                           postponed_deps,
+                                           postponed_cfgs,
+                                           postponed_poss);
 
-              prog = (ndep != p->dependencies->size ());
+              prog = (pas.find (p) == pas.end () ||
+                      ndep != p->dependencies->size ());
 
-              // Save the potential new postpones.
+              // Save the potential new postponements.
               //
               if (prog)
               {
@@ -2924,9 +6552,14 @@ namespace bpkg
               size_t npr (postponed_repo.size ());
               postponed_repo.insert (prs.begin (), prs.end ());
 
-              // Note that not collecting any alternative-relative postpones
-              // but producing new repository-related postpones is progress
-              // nevertheless.
+              // Note that not collecting any alternative-relative
+              // postponements but producing new repository-related
+              // postponements is progress nevertheless.
+              //
+              // Note that we don't need to check for new configuration-
+              // related postponements here since if they are present, then
+              // this package wouldn't be in pas and so prog would be true
+              // (see above for details).
               //
               if (!prog)
                 prog = (npr != postponed_repo.size ());
@@ -2935,10 +6568,194 @@ namespace bpkg
                 break;
             }
           }
+
+          if (prog)
+            continue;
+        }
+
+        assert (!prog);
+
+        // If we still have any non-negotiated clusters and non-replace
+        // postponed positions, then it's possible one of them is the cross-
+        // dependent pathological case where we will never hit it unless we
+        // force the re-evaluation to earlier position (similar to the
+        // single-dependent case, which we handle accurately). For example:
+        //
+        // tex: depends: libbar(c)
+        //      depends: libfoo(c)
+        //
+        // tix: depends: libbar(c)
+        //      depends: tex(c)
+        //
+        // Here tex and tix are existing dependent and we are upgrading tex.
+        //
+        // While it would be ideal to handle such cases accurately, it's not
+        // trivial. So for now we resort to the following heuristics: when
+        // left with no other option, we treat the first encountered non-
+        // replace position as replace and see if that helps move things
+        // forward.
+        //
+        if (!postponed_cfgs.negotiated () &&
+            find_if (postponed_poss.begin (), postponed_poss.end (),
+                     [] (const auto& v) {return !v.second.replace;}) !=
+            postponed_poss.end ()         &&
+            !postponed_poss.replace)
+        {
+          l5 ([&]{trace << "non-negotiated clusters left and non-replace "
+                        << "postponed positions are present, overriding first "
+                        << "encountered non-replace position to replace";});
+
+          postponed_poss.replace = true;
+          prog = true;
+          continue; // Go back to negotiating skipped cluster.
+        }
+
+        // Finally, erase the bogus postponements and re-collect from scratch,
+        // if any (see postponed_dependencies for details).
+        //
+        // Note that we used to re-collect such postponements in-place but
+        // re-doing from scratch feels more correct (i.e., we may end up doing
+        // it earlier which will affect dependency alternatives).
+        //
+        postponed_deps.cancel_bogus (trace, false /* initial_collection */);
+      }
+
+      // Check if any negotiatiated configurations ended up with any bogus
+      // variables (see retry_configuration catch block for background).
+      //
+      // Note that we could potentially end up yo-yo'ing: we remove a bogus
+      // and that causes the original dependent to get re-visited which in
+      // turn re-introduces the bogus. In other words, one of the bogus
+      // variables which we have removed are actually the cause of no longer
+      // needing the dependent that introduced it. Feels like the correct
+      // outcome of this should be keeping the bogus variable that triggered
+      // yo-yo'ing. Of course, there could be some that we should keep and
+      // some that we should drop and figuring this out would require retrying
+      // all possible combinations. An alternative solution would be to detect
+      // yo-yo'ing, print the bogus variables involved, and ask the user to
+      // choose (with an override) which ones to keep. Let's go with this for
+      // now.
+      //
+      {
+        // On the first pass see if we have anything bogus.
+        //
+        bool bogus (false);
+        for (postponed_configuration& pcfg: postponed_cfgs)
+        {
+          if (pcfg.negotiated && *pcfg.negotiated) // Negotiated.
+          {
+            for (package_configuration& cfg: pcfg.dependency_configurations)
+            {
+              for (config_variable_value& v: cfg)
+              {
+                if (v.dependent && !v.confirmed)
+                {
+                  bogus = true;
+                  break;
+                }
+              }
+              if (bogus) break;
+            }
+            if (bogus) break;
+          }
+        }
+
+        if (bogus)
+        {
+          // On the second pass calculate the checksum of all the negotiated
+          // clusters.
+          //
+          sha256 cs;
+          for (postponed_configuration& pcfg: postponed_cfgs)
+          {
+            if (pcfg.negotiated && *pcfg.negotiated)
+            {
+              for (package_configuration& cfg: pcfg.dependency_configurations)
+              {
+                for (config_variable_value& v: cfg)
+                {
+                  if (v.dependent)
+                    to_checksum (cs, v);
+                }
+              }
+            }
+          }
+
+          bool cycle;
+          {
+            string s (cs.string ());
+            if (find (postponed_cfgs_history.begin (),
+                      postponed_cfgs_history.end (),
+                      s) == postponed_cfgs_history.end ())
+            {
+              postponed_cfgs_history.push_back (move (s));
+              cycle = false;
+            }
+            else
+              cycle = true;
+          }
+
+          // On the third pass we either retry or diagnose.
+          //
+          diag_record dr;
+          if (cycle)
+          {
+            dr <<
+              fail << "unable to remove bogus configuration values without "
+                   << "causing configuration refinement cycle" <<
+              info << "consider manually specifying one or more of the "
+                   << "following variables as user configuration";
+          }
+
+          for (postponed_configuration& pcfg: postponed_cfgs)
+          {
+            optional<package_key> dept; // Bogus dependent.
+
+            if (pcfg.negotiated && *pcfg.negotiated)
+            {
+              for (package_configuration& cfg: pcfg.dependency_configurations)
+              {
+                // Note that the entire dependency configuration may end up
+                // being "bogus" (i.e., it does not contain any configuration
+                // variables with a confirmed dependent). But that will be
+                // handled naturally: we will either no longer have this
+                // dependency in the cluster and thus never call its
+                // skeleton's dependent_config() or this call will be no-op
+                // since it won't find any dependent variables.
+                //
+                for (config_variable_value& v: cfg)
+                {
+                  if (v.dependent && !v.confirmed)
+                  {
+                    if (!dept)
+                      dept = move (v.dependent);
+
+                    if (cycle)
+                      dr << "\n    " << v.serialize_cmdline ();
+                    else
+                      v.undefine ();
+                  }
+                }
+              }
+
+              if (dept)
+              {
+                if (cycle)
+                  break;
+                else
+                  throw retry_configuration {pcfg.depth, move (*dept)};
+              }
+            }
+
+            if (dept)
+              break;
+          }
         }
       }
 
-      // If any postponed builds remained, then perform the diagnostics run.
+      // If any postponed_{repo,alts} builds remained, then perform the
+      // diagnostics run. Naturally we shouldn't have any postponed_cfgs
+      // without one of the former.
       //
       if (!postponed_repo.empty ())
       {
@@ -2949,10 +6766,15 @@ namespace bpkg
                                      fdb,
                                      rpt_depts,
                                      apc,
+                                     false /* initial_collection */,
+                                     replaced_vers,
+                                     dep_chain,
                                      nullptr,
                                      nullptr,
                                      0,
-                                     dep_chain);
+                                     postponed_deps,
+                                     postponed_cfgs,
+                                     postponed_poss);
 
         assert (false); // Can't be here.
       }
@@ -2966,13 +6788,35 @@ namespace bpkg
                                      fdb,
                                      rpt_depts,
                                      apc,
+                                     false /* initial_collection */,
+                                     replaced_vers,
+                                     dep_chain,
                                      nullptr,
                                      nullptr,
                                      0,
-                                     dep_chain);
+                                     postponed_deps,
+                                     postponed_cfgs,
+                                     postponed_poss);
 
         assert (false); // Can't be here.
       }
+
+      // While the assumption is that we shouldn't leave any non-negotiated
+      // clusters, we can potentially miss some corner cases in the above
+      // "skip configuration" logic. Let's thus trace the non-negotiated
+      // clusters before the assertion.
+      //
+#ifndef NDEBUG
+      for (const postponed_configuration& cfg: postponed_cfgs)
+      {
+        if (!cfg.negotiated || !*cfg.negotiated)
+          trace << "unexpected non-negotiated cluster " << cfg;
+      }
+
+      assert (postponed_cfgs.negotiated ());
+#endif
+
+      l5 ([&]{trace << "end" << trace_suffix;});
     }
 
     // Order the previously-collected package with the specified name
@@ -2982,7 +6826,7 @@ namespace bpkg
     // only the specified configuration. Otherwise, treat the package as a
     // dependency and use the custom search function to find its build
     // configuration. Failed that, search for it recursively (see
-    // config_package_map::find_dependency() for details).
+    // package_map::find_dependency() for details).
     //
     // Recursively order the package dependencies being ordered failing if a
     // dependency cycle is detected. If reorder is true, then reorder this
@@ -2995,7 +6839,7 @@ namespace bpkg
            const function<find_database_function>& fdb,
            bool reorder = true)
     {
-      config_package_names chain;
+      package_refs chain;
       return order (db, name, buildtime, chain, fdb, reorder);
     }
 
@@ -3070,8 +6914,8 @@ namespace bpkg
           auto i (map_.find (ddb, dn));
 
           // Make sure the up/downgraded package still satisfies this
-          // dependent. But first "prune" if this is a replaced prerequisite
-          // of the repointed dependent.
+          // dependent. But first "prune" if the dependent is being dropped or
+          // this is a replaced prerequisite of the repointed dependent.
           //
           // Note that the repointed dependents are always collected and have
           // all their collected prerequisites ordered (including new and old
@@ -3081,37 +6925,34 @@ namespace bpkg
 
           if (i != map_.end () && i->second.position != end ())
           {
+            build_package& dp (i->second.package);
+
+            // Skip the droped dependent.
+            //
+            if (dp.action && *dp.action == build_package::drop)
+              continue;
+
             repointed_dependents::const_iterator j (
-              rpt_depts.find (config_package {ddb, dn}));
+              rpt_depts.find (package_key {ddb, dn}));
 
             if (j != rpt_depts.end ())
             {
-              const map<config_package, bool>& prereqs_flags (j->second);
+              const map<package_key, bool>& prereqs_flags (j->second);
 
-              auto k (prereqs_flags.find (config_package {pdb, n}));
+              auto k (prereqs_flags.find (package_key {pdb, n}));
 
               if (k != prereqs_flags.end () && !k->second)
                 continue;
             }
 
-            build_package& dp (i->second.package);
-            const shared_ptr<selected_package>& dsp (dp.selected);
-
             // There is one tricky aspect: the dependent could be in the
-            // process of being up/downgraded as well. In this case all we
-            // need to do is detect this situation and skip the test since all
-            // the (new) contraints of this package have been satisfied in
-            // collect_build().
+            // process of being reconfigured or up/downgraded as well. In this
+            // case all we need to do is detect this situation and skip the
+            // test since all the (new) constraints of this package have been
+            // satisfied in collect_build().
             //
             if (check)
-            {
-              check = dp.available == nullptr ||
-                      (dsp->system () == dp.system &&
-                       dsp->version == dp.available_version () &&
-                       (dp.system               ||
-                        dp.config_vars.empty () ||
-                        !has_buildfile_clause (dp.available->dependencies)));
-            }
+              check = !dp.dependencies;
           }
 
           if (check)
@@ -3140,8 +6981,8 @@ namespace bpkg
               string rb;
               if (!p.user_selection ())
               {
-                for (const config_package& cp: p.required_by)
-                  rb += (rb.empty () ? " " : ", ") + cp.string ();
+                for (const package_key& pk: p.required_by)
+                  rb += (rb.empty () ? " " : ", ") + pk.string ();
               }
 
               if (!rb.empty ())
@@ -3164,7 +7005,9 @@ namespace bpkg
           {
             shared_ptr<selected_package> dsp (ddb.load<selected_package> (dn));
 
-            bool system (dsp->system ()); // Save before the move(dsp) call.
+            // A system package cannot be a dependent.
+            //
+            assert (!dsp->system ());
 
             return build_package {
               build_package::adjust,
@@ -3173,19 +7016,21 @@ namespace bpkg
                 nullptr,                   // No available pkg/repo fragment.
                 nullptr,
                 nullopt,                   // Dependencies.
+                nullopt,                   // Dependencies alternatives.
                 nullopt,                   // Package skeleton.
                 nullopt,                   // Postponed dependency alternatives.
+                false,                     // Recursive collection.
                 nullopt,                   // Hold package.
                 nullopt,                   // Hold version.
                 {},                        // Constraints.
-                system,
+                false,                     // System.
                 false,                     // Keep output directory.
                 false,                     // Disfigure (from-scratch reconf).
                 false,                     // Configure-only.
                 nullopt,                   // Checkout root.
                 false,                     // Checkout purge.
                 strings (),                // Configuration variables.
-                {config_package {pdb, n}}, // Required by (dependency).
+                {package_key {pdb, n}},    // Required by (dependency).
                 false,                     // Required by dependents.
                 build_package::adjust_reconfigure};
           };
@@ -3194,11 +7039,10 @@ namespace bpkg
           // list, the package is in the map (but not on the list) and it
           // is in neither.
           //
-          // If the existing entry is a drop, then we skip it. If it is
-          // pre-entered, is an adjustment, or is a build that is not supposed
-          // to be built (not in the list), then we merge it into the new
-          // adjustment entry. Otherwise (is a build in the list), we just add
-          // the reconfigure adjustment flag to it.
+          // If the existing entry is pre-entered, is an adjustment, or is a
+          // build that is not supposed to be built (not in the list), then we
+          // merge it into the new adjustment entry. Otherwise (is a build in
+          // the list), we just add the reconfigure adjustment flag to it.
           //
           if (i != map_.end ())
           {
@@ -3209,11 +7053,6 @@ namespace bpkg
                 *dp.action != build_package::build || // Non-build.
                 dpos == end ())                       // Build not in the list.
             {
-              // Skip the droped package.
-              //
-              if (dp.action && *dp.action == build_package::drop)
-                continue;
-
               build_package bp (adjustment ());
               bp.merge (move (dp));
               dp = move (bp);
@@ -3246,7 +7085,7 @@ namespace bpkg
           {
             // Don't move dn since it is used by adjustment().
             //
-            i = map_.emplace (config_package {ddb, dn},
+            i = map_.emplace (package_key {ddb, dn},
                               data_type {end (), adjustment ()}).first;
 
             i->second.position = insert (pos, i->second.package);
@@ -3279,29 +7118,272 @@ namespace bpkg
         p.second.position = end ();
     }
 
+    // Verify that builds ordering is consistent across all the data
+    // structures and the ordering expectations are fulfilled (real build
+    // actions are all ordered, etc).
+    //
+    void
+    verify_ordering () const
+    {
+      for (const auto& b: map_)
+      {
+        const build_package& bp (b.second.package);
+
+        auto i (find_if (begin (), end (),
+                         [&bp] (const build_package& p) {return &p == &bp;}));
+
+        // List ordering must properly be reflected in the tree entries.
+        //
+        assert (i == b.second.position);
+
+        // Pre-entered builds must never be ordered and the real build actions
+        // (builds, adjustments, etc) must all be ordered.
+        //
+        // Note that the later was not the case until we've implemented
+        // re-collection from scratch after the package version replacement
+        // (see replaced_versions for details). Before that the whole
+        // dependency trees from the being replaced dependent stayed in the
+        // map.
+        //
+        assert (bp.action.has_value () == (i != end ()));
+      }
+    }
+
+  private:
+    // Return the list of existing dependents that has a configuration clause
+    // for the specified dependency. Skip dependents which are being built and
+    // require recursive recollection or dropped (present in the map) or
+    // expected to be built or dropped (present in rpt_depts or replaced_vers).
+    //
+    // Optionally, specify the function which can verify the dependent build
+    // and decide whether to override the default behavior and still add the
+    // dependent package to the resulting list, returning true in this case.
+    //
+    struct existing_dependent
+    {
+      reference_wrapper<database>   db;
+      shared_ptr<selected_package>  selected;
+      pair<size_t, size_t>          dependency_position;
+    };
+
+    using verify_dependent_build_function = bool (const package_key&,
+                                                  pair<size_t, size_t>);
+
+    vector<existing_dependent>
+    query_existing_dependents (
+      tracer& trace,
+      database& db,
+      const package_name& name,
+      const replaced_versions& replaced_vers,
+      const repointed_dependents& rpt_depts,
+      const function<verify_dependent_build_function>& vdb = nullptr)
+    {
+      vector<existing_dependent> r;
+
+      lazy_shared_ptr<selected_package> sp (db, name);
+
+      for (database& ddb: db.dependent_configs ())
+      {
+        for (auto& pd: query_dependents (ddb, name, db))
+        {
+          shared_ptr<selected_package> dsp (
+            ddb.load<selected_package> (pd.name));
+
+          auto i (dsp->prerequisites.find (sp));
+          assert (i != dsp->prerequisites.end ());
+
+          const auto& pos (i->second.config_position);
+
+          if (pos.first != 0) // Has config clause?
+          {
+            package_key pk (ddb, pd.name);
+
+            if (rpt_depts.find (pk) != rpt_depts.end ())
+            {
+              l5 ([&]{trace << "skip repointed existing dependent " << pk
+                            << " of dependency " << name << db;});
+              continue;
+            }
+
+            // Ignore dependent which is already being built or dropped.
+            //
+            const build_package* p (entered_build (pk));
+
+            if (p != nullptr && p->action)
+            {
+              bool build;
+              if (((build = *p->action == build_package::build) &&
+                   (p->system || p->recollect_recursively (rpt_depts))) ||
+                  *p->action == build_package::drop)
+              {
+                if (!build || !vdb || !vdb (pk, pos))
+                {
+                  l5 ([&]{trace << "skip being "
+                                << (build ? "built" : "dropped")
+                                << " existing dependent " << pk
+                                << " of dependency " << name << db;});
+                  continue;
+                }
+              }
+            }
+
+            // Ignore dependent which is expected to be built or dropped.
+            //
+            auto vi (replaced_vers.find (pk));
+            if (vi != replaced_vers.end () && !vi->second.replaced)
+            {
+              bool build (vi->second.available != nullptr);
+
+              l5 ([&]{trace << "skip expected to be "
+                            << (build ? "built" : "dropped")
+                            << " existing dependent " << pk
+                            << " of dependency " << name << db;});
+
+              continue;
+            }
+
+            r.push_back (existing_dependent {ddb, move (dsp), pos});
+          }
+        }
+      }
+
+      return r;
+    }
+
+    // Update the existing dependent object (previously obtained with the
+    // query_existing_dependents() call) with the new dependency position and
+    // collect the dependency referred by this position. Return the pointer to
+    // the collected build package object.
+    //
+    const build_package*
+    replace_existing_dependent_dependency (
+      tracer& trace,
+      const pkg_build_options& o,
+      existing_dependent& ed,
+      pair<size_t, size_t> pos,
+      const function<find_database_function>& fdb,
+      const repointed_dependents& rpt_depts,
+      const function<add_priv_cfg_function>& apc,
+      bool initial_collection,
+      replaced_versions& replaced_vers,
+      postponed_configurations& postponed_cfgs)
+    {
+      // The repointed dependent cannot be returned by
+      // query_existing_dependents(). Note that the repointed dependent
+      // references both old and new prerequisites.
+      //
+      assert (rpt_depts.find (package_key (ed.db, ed.selected->name)) ==
+              rpt_depts.end ());
+
+      shared_ptr<selected_package> dsp;
+      database* pdb (nullptr);
+      const version_constraint* vc (nullptr);
+
+      // Find the dependency for this earlier dependency position. We know
+      // it must be there since it's with configuration.
+      //
+      for (const auto& p: ed.selected->prerequisites)
+      {
+        if (p.second.config_position == pos)
+        {
+          pdb = &p.first.database ();
+
+          dsp = p.first.load ();
+
+          l5 ([&]{trace << "replace dependency at index "
+                        << ed.dependency_position.first
+                        << " of existing dependent " << *ed.selected
+                        << ed.db << " with dependency " << *dsp
+                        << *pdb << " at index " << pos.first;});
+
+          if (p.second.constraint)
+            vc = &*p.second.constraint;
+        }
+      }
+
+      assert (dsp != nullptr);
+
+      package_key pk (*pdb, dsp->name);
+
+      // Adjust the existing dependent entry.
+      //
+      ed.dependency_position = pos;
+
+      // Collect the package build for this dependency.
+      //
+      pair<shared_ptr<available_package>,
+           lazy_shared_ptr<repository_fragment>> rp (
+             find_available_fragment (o, pk.db, dsp));
+
+      bool system (dsp->system ());
+
+      package_key dpk (ed.db, ed.selected->name);
+
+      build_package p {
+        build_package::build,
+          pk.db,
+          move (dsp),
+          move (rp.first),
+          move (rp.second),
+          nullopt,                    // Dependencies.
+          nullopt,                    // Dependencies alternatives.
+          nullopt,                    // Package skeleton.
+          nullopt,                    // Postponed dependency alternatives.
+          false,                      // Recursive collection.
+          nullopt,                    // Hold package.
+          nullopt,                    // Hold version.
+          {},                         // Constraints.
+          system,                     // System.
+          false,                      // Keep output directory.
+          false,                      // Disfigure (from-scratch reconf).
+          false,                      // Configure-only.
+          nullopt,                    // Checkout root.
+          false,                      // Checkout purge.
+          strings (),                 // Configuration variables.
+          {dpk},                      // Required by (dependent).
+          true,                       // Required by dependents.
+          build_package::adjust_reconfigure};
+
+      if (vc != nullptr)
+        p.constraints.emplace_back (dpk.db, dpk.name.string (), *vc);
+
+      // Note: not recursive.
+      //
+      collect_build (o,
+                     move (p),
+                     fdb,
+                     rpt_depts,
+                     apc,
+                     initial_collection,
+                     replaced_vers,
+                     postponed_cfgs);
+
+      return entered_build (pk);
+    }
+
   private:
-    struct config_package_name
+    struct package_ref
     {
       database& db;
       const package_name& name;
 
       bool
-      operator== (const config_package_name& v)
+      operator== (const package_ref& v)
       {
         return name == v.name && db == v.db;
       }
     };
-    using config_package_names = small_vector<config_package_name, 16>;
+    using package_refs = small_vector<package_ref, 16>;
 
     iterator
     order (database& db,
            const package_name& name,
            optional<bool> buildtime,
-           config_package_names& chain,
+           package_refs& chain,
            const function<find_database_function>& fdb,
            bool reorder)
     {
-      config_package_map::iterator mi;
+      package_map::iterator mi;
 
       if (buildtime)
       {
@@ -3326,7 +7408,7 @@ namespace bpkg
 
       // Make sure there is no dependency cycle.
       //
-      config_package_name cp {pdb, name};
+      package_ref cp {pdb, name};
       {
         auto i (find (chain.begin (), chain.end (), cp));
 
@@ -3335,7 +7417,7 @@ namespace bpkg
           diag_record dr (fail);
           dr << "dependency cycle detected involving package " << name << pdb;
 
-          auto nv = [this] (const config_package_name& cp)
+          auto nv = [this] (const package_ref& cp)
           {
             auto mi (map_.find (cp.db, cp.name));
             assert (mi != map_.end ());
@@ -3554,15 +7636,17 @@ namespace bpkg
       build_package package;
     };
 
-    class config_package_map: public map<config_package, data_type>
+    class package_map: public map<package_key, data_type>
     {
     public:
-      using base_type = map<config_package, data_type>;
+      using base_type = map<package_key, data_type>;
+
+      using base_type::find;
 
       iterator
       find (database& db, const package_name& pn)
       {
-        return base_type::find (config_package {db, pn});
+        return find (package_key {db, pn});
       }
 
       // Try to find a package build in the dependency configurations (see
@@ -3587,7 +7671,7 @@ namespace bpkg
             else
               fail << "building package " << pn << " in multiple "
                    << "configurations" <<
-                info << r->first.db.config_orig <<
+                info << r->first.db.get().config_orig <<
                 info << ldb.config_orig <<
                 info << "use --config-* to select package configuration";
           }
@@ -3596,7 +7680,7 @@ namespace bpkg
         return r;
       }
     };
-    config_package_map map_;
+    package_map map_;
   };
 
   // Return a patch version constraint for the selected package if it has a
@@ -3699,19 +7783,19 @@ namespace bpkg
     bool                                       system;
   };
 
-  struct config_package_dependent
+  struct dependent_constraint
   {
     database&                    db;
     shared_ptr<selected_package> package;
     optional<version_constraint> constraint;
 
-    config_package_dependent (database& d,
-                              shared_ptr<selected_package> p,
-                              optional<version_constraint> c)
+    dependent_constraint (database& d,
+                          shared_ptr<selected_package> p,
+                          optional<version_constraint> c)
         : db (d), package (move (p)), constraint (move (c)) {}
   };
 
-  using config_package_dependents = vector<config_package_dependent>;
+  using dependent_constraints = vector<dependent_constraint>;
 
   static optional<evaluate_result>
   evaluate_dependency (database&,
@@ -3723,7 +7807,7 @@ namespace bpkg
                        bool patch,
                        bool explicitly,
                        const config_repo_fragments&,
-                       const config_package_dependents&,
+                       const dependent_constraints&,
                        bool ignore_unsatisfiable);
 
   // If there are no user expectations regarding this dependency, then we give
@@ -3927,7 +8011,7 @@ namespace bpkg
     // dependency.
     //
     config_repo_fragments repo_frags;
-    config_package_dependents dependents;
+    dependent_constraints dpt_constrs;
 
     for (auto& pd: pds)
     {
@@ -3941,7 +8025,7 @@ namespace bpkg
         available_package_id (p->name, p->version),
         repo_frags);
 
-      dependents.emplace_back (ddb, move (p), move (dep.constraint));
+      dpt_constrs.emplace_back (ddb, move (p), move (dep.constraint));
     }
 
     return evaluate_dependency (db,
@@ -3953,7 +8037,7 @@ namespace bpkg
                                 i->patch,
                                 true /* explicitly */,
                                 repo_frags,
-                                dependents,
+                                dpt_constrs,
                                 ignore_unsatisfiable);
   }
 
@@ -3990,7 +8074,7 @@ namespace bpkg
                        bool patch,
                        bool explicitly,
                        const config_repo_fragments& rfs,
-                       const config_package_dependents& dependents,
+                       const dependent_constraints& dpt_constrs,
                        bool ignore_unsatisfiable)
   {
     tracer trace ("evaluate_dependency");
@@ -4009,8 +8093,10 @@ namespace bpkg
     // Build the list of available packages for the potential up/down-grade
     // to, in the version-descending order. If patching, then we constrain the
     // choice with the latest patch version and place no constraints if
-    // upgrading. For a system package we also put no constraints just to make
-    // sure that the package is recognized.
+    // upgrading. For a system package we will try to find the available
+    // package that matches the user-specified system version (preferable for
+    // the configuration negotiation machinery) and, if fail, fallback to
+    // picking the latest one just to make sure the package is recognized.
     //
     optional<version_constraint> c;
 
@@ -4029,13 +8115,16 @@ namespace bpkg
         }
       }
     }
-    else if (!dsys)
+    else if (!dsys || !wildcard (*dvc))
       c = dvc;
 
     vector<pair<shared_ptr<available_package>,
                 lazy_shared_ptr<repository_fragment>>> afs (
       find_available (nm, c, rfs));
 
+    if (afs.empty () && dsys && c)
+      afs = find_available (nm, nullopt, rfs);
+
     // Go through up/down-grade candidates and pick the first one that
     // satisfies all the dependents. Collect (and sort) unsatisfied dependents
     // per the unsatisfiable version in case we need to print them.
@@ -4090,7 +8179,7 @@ namespace bpkg
       bool satisfactory (true);
       sp_set unsatisfied_dependents;
 
-      for (const auto& dp: dependents)
+      for (const auto& dp: dpt_constrs)
       {
         if (!satisfies (av, dp.constraint))
         {
@@ -4327,7 +8416,7 @@ namespace bpkg
     // dependency.
     //
     config_repo_fragments repo_frags;
-    config_package_dependents dependents;
+    dependent_constraints dpt_constrs;
 
     // Only collect repository fragments (for best version selection) of
     // (immediate) dependents that have a hit (direct or indirect) in recs.
@@ -4341,7 +8430,7 @@ namespace bpkg
       {
         shared_ptr<selected_package> p (ddb.load<selected_package> (pd.name));
 
-        dependents.emplace_back (ddb, p, move (pd.constraint));
+        dpt_constrs.emplace_back (ddb, p, move (pd.constraint));
 
         if (optional<bool> u = upgrade_dependencies (ddb, pd.name, recs))
         {
@@ -4380,7 +8469,7 @@ namespace bpkg
                            !*upgrade /* patch */,
                            false /* explicitly */,
                            repo_frags,
-                           dependents,
+                           dpt_constrs,
                            ignore_unsatisfiable));
 
     // Translate the "no change" result into nullopt.
@@ -5564,7 +9653,7 @@ namespace bpkg
 
     // List of package configurations specified on the command line.
     //
-    vector<config_package> pkg_confs;
+    vector<package_key> pkg_confs;
 
     // Separate the packages specified on the command line into to hold and to
     // up/down-grade as dependencies, and save dependents whose dependencies
@@ -5578,16 +9667,16 @@ namespace bpkg
       // Check if the package is a duplicate. Return true if it is but
       // harmless.
       //
-      struct config_package_key // Like config_package but with NULL'able db.
+      struct sys_package_key // Like package_key but with NULL'able db.
       {
         package_name name;
         database*    db;   // Can be NULL for system dependency.
 
-        config_package_key (package_name n, database* d)
+        sys_package_key (package_name n, database* d)
             : name (move (n)), db (d) {}
 
         bool
-        operator< (const config_package_key& v) const
+        operator< (const sys_package_key& v) const
         {
           if (int r = name.compare (v.name))
             return r < 0;
@@ -5598,14 +9687,14 @@ namespace bpkg
         }
       };
 
-      map<config_package_key, pkg_arg> package_map;
+      map<sys_package_key, pkg_arg> package_map;
 
       auto check_dup = [&package_map, &arg_string, &arg_parsed]
                        (const pkg_arg& pa) -> bool
       {
         assert (arg_parsed (pa));
 
-        auto r (package_map.emplace (config_package_key {pa.name, pa.db}, pa));
+        auto r (package_map.emplace (sys_package_key {pa.name, pa.db}, pa));
 
         const pkg_arg& a (r.first->second);
         assert (arg_parsed (a));
@@ -5852,14 +9941,19 @@ namespace bpkg
               lazy_shared_ptr<repository_fragment> root (*pdb, empty_string);
 
               // Either get the user-specified version or the latest allowed
-              // for a source code package. For a system package we pick the
-              // latest one just to make sure the package is recognized.
+              // for a source code package. For a system package we will try
+              // to find the available package that matches the user-specified
+              // system version (preferable for the configuration negotiation
+              // machinery) and, if fail, fallback to picking the latest one
+              // just to make sure the package is recognized.
               //
               optional<version_constraint> c;
 
+              bool sys (arg_sys (pa));
+
               if (!pa.constraint)
               {
-                assert (!arg_sys (pa));
+                assert (!sys);
 
                 if (pa.options.patch () &&
                     (sp = pdb->find<selected_package> (pa.name)) != nullptr)
@@ -5878,11 +9972,14 @@ namespace bpkg
                   patch = true;
                 }
               }
-              else if (!arg_sys (pa))
+              else if (!sys || !wildcard (*pa.constraint))
                 c = pa.constraint;
 
               auto rp (find_available_one (pa.name, c, root));
 
+              if (rp.first == nullptr && sys && c)
+                rp = find_available_one (pa.name, nullopt, root);
+
               ap = move (rp.first);
               af = move (rp.second);
             }
@@ -5918,8 +10015,7 @@ namespace bpkg
 
           if (r)
           {
-            l4 ([&]{trace << "stashing recursive package "
-                          << arg_string (pa);});
+            l4 ([&]{trace << "stash recursive package " << arg_string (pa);});
 
             // The above options are meaningless for system packages, so we
             // just ignore them for a system dependency with unspecified
@@ -5934,8 +10030,7 @@ namespace bpkg
         //
         if (pa.options.dependency ())
         {
-          l4 ([&]{trace << "stashing dependency package "
-                        << arg_string (pa);});
+          l4 ([&]{trace << "stash dependency package " << arg_string (pa);});
 
           bool sys (arg_sys (pa));
 
@@ -6146,8 +10241,10 @@ namespace bpkg
           move (ap),
           move (af),
           nullopt,                    // Dependencies.
+          nullopt,                    // Dependencies alternatives.
           nullopt,                    // Package skeleton.
           nullopt,                    // Postponed dependency alternatives.
+          false,                      // Recursive collection.
           true,                       // Hold package.
           pa.constraint.has_value (), // Hold version.
           {},                         // Constraints.
@@ -6160,11 +10257,11 @@ namespace bpkg
            : optional<dir_path> ()),
           pa.options.checkout_purge (),
           move (pa.config_vars),
-          {config_package {mdb, ""}}, // Required by (command line).
+          {package_key {mdb, ""}},    // Required by (command line).
           false,                      // Required by dependents.
           0};                         // State flags.
 
-        l4 ([&]{trace << "stashing held package "
+        l4 ([&]{trace << "stash held package "
                       << p.available_name_version_db ();});
 
         // "Fix" the version the user asked for by adding the constraint.
@@ -6256,24 +10353,26 @@ namespace bpkg
                 move (sp),
                 move (ap),
                 move (apr.second),
-                nullopt,                    // Dependencies.
-                nullopt,                    // Package skeleton.
-                nullopt,                    // Postponed dependency alternatives.
-                true,                       // Hold package.
-                false,                      // Hold version.
-                {},                         // Constraints.
-                false,                      // System package.
+                nullopt,                 // Dependencies.
+                nullopt,                 // Dependencies alternatives.
+                nullopt,                 // Package skeleton.
+                nullopt,                 // Postponed dependency alternatives.
+                false,                   // Recursive collection.
+                true,                    // Hold package.
+                false,                   // Hold version.
+                {},                      // Constraints.
+                false,                   // System package.
                 keep_out,
                 o.disfigure (),
-                false,                      // Configure-only.
-                nullopt,                    // Checkout root.
-                false,                      // Checkout purge.
-                strings (),                 // Configuration variables.
-                {config_package {mdb, ""}}, // Required by (command line).
-                false,                      // Required by dependents.
-                0};                         // State flags.
-
-            l4 ([&]{trace << "stashing held package "
+                false,                   // Configure-only.
+                nullopt,                 // Checkout root.
+                false,                   // Checkout purge.
+                strings (),              // Configuration variables.
+                {package_key {mdb, ""}}, // Required by (command line).
+                false,                   // Required by dependents.
+                0};                      // State flags.
+
+            l4 ([&]{trace << "stash held package "
                           << p.available_name_version_db ();});
 
             hold_pkgs.push_back (move (p));
@@ -6323,18 +10422,18 @@ namespace bpkg
 
         linked_databases ddbs (db.dependency_configs (nm, buildtime));
 
-        for (const config_package& cp: pkg_confs)
+        for (const package_key& p: pkg_confs)
         {
-          if (cp.name == nm &&
-              find (ddbs.begin (), ddbs.end (), cp.db) != ddbs.end ())
+          if (p.name == nm &&
+              find (ddbs.begin (), ddbs.end (), p.db) != ddbs.end ())
           {
             if (r == nullptr)
-              r = &cp.db;
+              r = &p.db.get ();
             else
-              fail << "multiple " << cp.db.type << " configurations "
+              fail << "multiple " << p.db.get ().type << " configurations "
                    << "specified for package " << nm <<
                 info << r->config_orig <<
-                info << cp.db.config_orig;
+                info << p.db.get ().config_orig;
           }
         }
 
@@ -6401,6 +10500,10 @@ namespace bpkg
       };
       vector<dep> deps;
 
+      replaced_versions replaced_vers;
+      postponed_dependencies postponed_deps;
+      postponed_positions postponed_poss;
+
       // Map the repointed dependents to the replacement flags (see
       // repointed_dependents for details), unless --no-move is specified.
       //
@@ -6427,7 +10530,7 @@ namespace bpkg
           for (shared_ptr<selected_package> sp:
                  pointer_result (cdb.query<selected_package> (q)))
           {
-            map<config_package, bool> ps; // Old/new prerequisites.
+            map<package_key, bool> ps; // Old/new prerequisites.
 
             for (const auto& p: sp->prerequisites)
             {
@@ -6447,13 +10550,13 @@ namespace bpkg
 
               if (pdb != nullptr && *pdb != db && pdb->type == db.type)
               {
-                ps.emplace (config_package {*pdb, name}, true);
-                ps.emplace (config_package {  db, name}, false);
+                ps.emplace (package_key {*pdb, name}, true);
+                ps.emplace (package_key {  db, name}, false);
               }
             }
 
             if (!ps.empty ())
-              rpt_depts.emplace (config_package {cdb, sp->name}, move (ps));
+              rpt_depts.emplace (package_key {cdb, sp->name}, move (ps));
           }
         }
 
@@ -6462,9 +10565,23 @@ namespace bpkg
 
       // Iteratively refine the plan with dependency up/down-grades/drops.
       //
-      for (bool refine (true), scratch (true); refine; )
+      // Note that we should not clean the deps list on scratch_col (scratch
+      // during the package collection) because we want to enter them before
+      // collect_build_postponed() and they could be the dependents that have
+      // the config clauses. In a sense, change to replaced_vers,
+      // postponed_deps, or postponed_poss maps should not affect the deps
+      // list. But not the other way around: a dependency erased from the deps
+      // list could have caused an entry in the replaced_vers, postponed_deps,
+      // and/or postponed_poss maps. And so we clean replaced_vers,
+      // postponed_deps, and postponed_poss on scratch_exe (scratch during the
+      // plan execution).
+      //
+      for (bool refine (true), scratch_exe (true), scratch_col (false);
+           refine; )
       {
-        l4 ([&]{trace << "refining execution plan"
+        bool scratch (scratch_exe || scratch_col);
+
+        l4 ([&]{trace << "refine package collection/plan execution"
                       << (scratch ? " from scratch" : "");});
 
         transaction t (mdb);
@@ -6486,38 +10603,81 @@ namespace bpkg
         // Temporarily add the replacement prerequisites to the repointed
         // dependent prerequisites sets and persist the changes.
         //
-        // Note that we don't copy the prerequisite constraints into the
-        // replacements, since they are unused in the collecting/ordering
-        // logic.
-        //
         for (auto& rd: rpt_depts)
         {
           database&           db (rd.first.db);
           const package_name& nm (rd.first.name);
 
           shared_ptr<selected_package> sp (db.load<selected_package> (nm));
+          package_prerequisites& prereqs (sp->prerequisites);
 
           for (const auto& prq: rd.second)
           {
             if (prq.second) // Prerequisite replacement?
             {
-              const config_package& cp (prq.first);
+              const package_key& p (prq.first);
 
-              auto i (sp->prerequisites.emplace (
-                        lazy_shared_ptr<selected_package> (cp.db, cp.name),
-                        nullopt));
+              // Find the being replaced prerequisite to copy it's information
+              // into the replacement.
+              //
+              auto i (find_if (prereqs.begin (), prereqs.end (),
+                               [&p] (const auto& pr)
+                               {
+                                 return pr.first.object_id () == p.name;
+                               }));
+
+              assert (i != prereqs.end ());
+
+              auto j (prereqs.emplace (
+                        lazy_shared_ptr<selected_package> (p.db.get (),
+                                                           p.name),
+                        i->second));
 
               // The selected package should only contain the old
               // prerequisites at this time, so adding a replacement should
               // always succeed.
               //
-              assert (i.second);
+              assert (j.second);
             }
           }
 
           db.update (sp);
         }
 
+        // Erase the replacements from the repointed dependents prerequisite
+        // sets and persist the changes.
+        //
+        auto restore_repointed_dependents = [&rpt_depts] ()
+        {
+          for (auto& rd: rpt_depts)
+          {
+            database&           db (rd.first.db);
+            const package_name& nm (rd.first.name);
+
+            shared_ptr<selected_package> sp (db.load<selected_package> (nm));
+
+            for (const auto& prq: rd.second)
+            {
+              if (prq.second) // Prerequisite replacement?
+              {
+                const package_key& p (prq.first);
+
+                size_t n (
+                  sp->prerequisites.erase (
+                    lazy_shared_ptr<selected_package> (p.db.get (), p.name)));
+
+                // The selected package should always contain the prerequisite
+                // replacement at this time, so its removal should always
+                // succeed.
+                //
+                assert (n == 1);
+              }
+            }
+
+            db.update (sp);
+          }
+        };
+
         // Pre-enter dependency to keep track of the desired versions and
         // options specified on the command line. In particular, if the
         // version is specified and the dependency is used as part of the
@@ -6528,8 +10688,7 @@ namespace bpkg
         // Also, if a dependency package already has selected package that
         // is held, then we need to unhold it.
         //
-        auto enter = [&mdb, &pkgs] (database& db,
-                                    const dependency_package& p)
+        auto enter = [&mdb, &pkgs] (database& db, const dependency_package& p)
         {
           build_package bp {
             nullopt,                    // Action.
@@ -6538,8 +10697,10 @@ namespace bpkg
             nullptr,                    // Available package/repo fragment.
             nullptr,
             nullopt,                    // Dependencies.
+            nullopt,                    // Dependencies alternatives.
             nullopt,                    // Package skeleton.
             nullopt,                    // Postponed dependency alternatives.
+            false,                      // Recursive collection.
             false,                      // Hold package.
             p.constraint.has_value (),  // Hold version.
             {},                         // Constraints.
@@ -6550,7 +10711,7 @@ namespace bpkg
             p.checkout_root,
             p.checkout_purge,
             p.config_vars,
-            {config_package {mdb, ""}}, // Required by (command line).
+            {package_key {mdb, ""}},    // Required by (command line).
             false,                      // Required by dependents.
             0};                         // State flags.
 
@@ -6620,179 +10781,329 @@ namespace bpkg
             }
           });
 
-        build_packages::postponed_packages postponed_repo;
-        build_packages::postponed_packages postponed_alts;
+        postponed_packages       postponed_repo;
+        postponed_packages       postponed_alts;
+        postponed_configurations postponed_cfgs;
+        strings                  postponed_cfgs_history;
 
-        if (scratch)
+        try
         {
-          pkgs.clear ();
-
-          // Pre-enter dependencies with specified configurations.
-          //
-          for (const dependency_package& p: dep_pkgs)
+          if (scratch)
           {
-            if (p.db != nullptr)
-              enter (*p.db, p);
-          }
+            pkgs.clear ();
 
-          // Pre-enter system dependencies with unspecified configuration for
-          // all dependency configurations, excluding those which already have
-          // this dependency pre-entered.
-          //
-          for (const dependency_package& p: dep_pkgs)
-          {
-            if (p.db == nullptr)
+            if (scratch_exe)
+            {
+              replaced_vers.clear ();
+              postponed_deps.clear ();
+              postponed_poss.clear ();
+
+              scratch_exe = false;
+            }
+            else if (scratch_col)
+            {
+              // Reset to detect bogus entries.
+              //
+              for (auto& rv: replaced_vers)
+                rv.second.replaced = false;
+
+              for (auto& pd: postponed_deps)
+              {
+                pd.second.wout_config = false;
+                pd.second.with_config = false;
+              }
+
+              for (auto& pd: postponed_poss)
+              {
+                pd.second.skipped = false;
+                pd.second.reevaluated = false;
+              }
+
+              scratch_col = false;
+            }
+
+            // Pre-enter dependencies with specified configurations.
+            //
+            for (const dependency_package& p: dep_pkgs)
+            {
+              if (p.db != nullptr)
+                enter (*p.db, p);
+            }
+
+            // Pre-enter system dependencies with unspecified configuration
+            // for all dependency configurations, excluding those which
+            // already have this dependency pre-entered.
+            //
+            for (const dependency_package& p: dep_pkgs)
+            {
+              if (p.db == nullptr)
+              {
+                for (database& db: dep_dbs)
+                {
+                  if (!pkgs.entered_build (db, p.name))
+                    enter_system_dependency (db, p);
+                }
+              }
+            }
+
+            // Pre-collect user selection to make sure dependency-forced
+            // up/down-grades are handled properly (i.e., the order in which we
+            // specify packages on the command line does not matter).
+            //
+            for (const build_package& p: hold_pkgs)
+              pkgs.collect_build (o,
+                                  p,
+                                  find_prereq_database,
+                                  rpt_depts,
+                                  add_priv_cfg,
+                                  true /* initial_collection */,
+                                  replaced_vers,
+                                  postponed_cfgs);
+
+            // Collect all the prerequisites of the user selection.
+            //
+            // Note that some of the user-selected packages can well be
+            // dependencies whose recursive processing should be postponed.
+            //
+            for (const build_package& p: hold_pkgs)
+            {
+              package_key pk (p.db, p.name ());
+
+              auto i (postponed_deps.find (pk));
+
+              if (i == postponed_deps.end ())
+              {
+                pkgs.collect_build_prerequisites (
+                  o,
+                  p.db,
+                  p.name (),
+                  find_prereq_database,
+                  rpt_depts,
+                  add_priv_cfg,
+                  true /* initial_collection */,
+                  replaced_vers,
+                  postponed_repo,
+                  postponed_alts,
+                  0 /* max_alt_index */,
+                  postponed_deps,
+                  postponed_cfgs,
+                  postponed_poss);
+              }
+              else
+              {
+                // Even though the user selection may have a configuration, we
+                // treat it as a dependent without any configuration because
+                // it is non-negotiable, known at the outset, and thus cannot
+                // be a reason to postpone anything.
+                //
+                i->second.wout_config = true;
+
+                l5 ([&]{trace << "dep-postpone user-specified " << pk;});
+              }
+            }
+
+            // Note that we need to collect unheld after prerequisites, not to
+            // overwrite the pre-entered entries before they are used to
+            // provide additional constraints for the collected prerequisites.
+            //
+            for (const dependency_package& p: dep_pkgs)
             {
-              for (database& db: dep_dbs)
+              auto unhold = [&p, &pkgs] (database& db)
               {
-                if (!pkgs.entered (db, p.name))
-                  enter_system_dependency (db, p);
+                shared_ptr<selected_package> sp (
+                  p.db != nullptr
+                  ? p.selected
+                  : db.find<selected_package> (p.name));
+
+                if (sp != nullptr && sp->hold_package)
+                  pkgs.collect_unhold (db, sp);
+              };
+
+              if (p.db != nullptr)
+              {
+                unhold (*p.db);
+              }
+              else
+              {
+                for (database& db: dep_dbs)
+                  unhold (db);
               }
             }
+
+            // Collect dependents whose dependencies need to be repointed to
+            // packages from different configurations.
+            //
+            pkgs.collect_repointed_dependents (o,
+                                               rpt_depts,
+                                               replaced_vers,
+                                               postponed_repo,
+                                               postponed_alts,
+                                               postponed_deps,
+                                               postponed_cfgs,
+                                               postponed_poss,
+                                               find_prereq_database,
+                                               add_priv_cfg);
           }
+          else
+            pkgs.clear_order (); // Only clear the ordered list.
 
-          // Pre-collect user selection to make sure dependency-forced
-          // up/down-grades are handled properly (i.e., the order in which we
-          // specify packages on the command line does not matter).
-          //
-          for (const build_package& p: hold_pkgs)
-            pkgs.collect_build (o,
-                                p,
-                                find_prereq_database,
-                                rpt_depts,
-                                add_priv_cfg);
-
-          // Collect all the prerequisites of the user selection.
+          // Add to the plan dependencies to up/down-grade/drop that were
+          // discovered on the previous iterations.
           //
-          for (const build_package& p: hold_pkgs)
-            pkgs.collect_build_prerequisites (o,
-                                              p.db,
-                                              p.name (),
-                                              postponed_repo,
-                                              postponed_alts,
-                                              0 /* max_alt_index */,
-                                              find_prereq_database,
-                                              rpt_depts,
-                                              add_priv_cfg);
-
-          // Note that we need to collect unheld after prerequisites, not to
-          // overwrite the pre-entered entries before they are used to provide
-          // additional constraints for the collected prerequisites.
+          // Note: this loop takes care of both the from-scratch and
+          // refinement cases.
           //
-          for (const dependency_package& p: dep_pkgs)
+          for (const dep& d: deps)
           {
-            auto unhold = [&p, &pkgs] (database& db)
-            {
-              shared_ptr<selected_package> sp (
-                p.db != nullptr
-                ? p.selected
-                : db.find<selected_package> (p.name));
-
-              if (sp != nullptr && sp->hold_package)
-                pkgs.collect_unhold (db, sp);
-            };
+            database& ddb (d.db);
 
-            if (p.db != nullptr)
+            if (d.available == nullptr)
             {
-              unhold (*p.db);
+              pkgs.collect_drop (o,
+                                 ddb,
+                                 ddb.load<selected_package> (d.name),
+                                 replaced_vers);
             }
             else
             {
-              for (database& db: dep_dbs)
-                unhold (db);
+              shared_ptr<selected_package> sp (
+                ddb.find<selected_package> (d.name));
+
+              // We will keep the output directory only if the external package
+              // is replaced with an external one (see above for details).
+              //
+              bool keep_out (o.keep_out () && sp->external ());
+
+              // Marking upgraded dependencies as "required by command line"
+              // may seem redundant as they should already be pre-entered as
+              // such (see above). But remember dependencies upgraded with
+              // -i|-r?  Note that the required_by data member should never be
+              // empty, as it is used in prompts/diagnostics.
+              //
+              build_package p {
+                build_package::build,
+                ddb,
+                move (sp),
+                d.available,
+                d.repository_fragment,
+                nullopt,                 // Dependencies.
+                nullopt,                 // Dependencies alternatives.
+                nullopt,                 // Package skeleton.
+                nullopt,                 // Postponed dependency alternatives.
+                false,                   // Recursive collection.
+                nullopt,                 // Hold package.
+                nullopt,                 // Hold version.
+                {},                      // Constraints.
+                d.system,
+                keep_out,
+                o.disfigure (),
+                false,                   // Configure-only.
+                nullopt,                 // Checkout root.
+                false,                   // Checkout purge.
+                strings (),              // Configuration variables.
+                {package_key {mdb, ""}}, // Required by (command line).
+                false,                   // Required by dependents.
+                0};                      // State flags.
+
+              build_package_refs dep_chain;
+
+              // Note: recursive.
+              //
+              pkgs.collect_build (o,
+                                  move (p),
+                                  find_prereq_database,
+                                  rpt_depts,
+                                  add_priv_cfg,
+                                  true /* initial_collection */,
+                                  replaced_vers,
+                                  postponed_cfgs,
+                                  &dep_chain,
+                                  &postponed_repo,
+                                  &postponed_alts,
+                                  &postponed_deps,
+                                  &postponed_poss);
             }
           }
 
-          // Collect dependents whose dependencies need to be repointed to
-          // packages from different configurations.
+          // Erase the bogus postponements and re-collect from scratch, if any
+          // (see postponed_dependencies for details).
           //
-          pkgs.collect_repointed_dependents (o,
-                                             rpt_depts,
-                                             postponed_repo,
-                                             postponed_alts,
-                                             find_prereq_database,
-                                             add_priv_cfg);
+          // Note that we used to re-collect such postponements in-place but
+          // re-doing from scratch feels more correct (i.e., we may end up
+          // doing it earlier which will affect dependency alternatives).
+          //
+          postponed_deps.cancel_bogus (trace, true /* initial_collection */);
 
-          scratch = false;
-        }
-        else
-          pkgs.clear_order (); // Only clear the ordered list.
+          // Now remove all the dependencies postponed during the initial
+          // collection since all this information is already in
+          // postponed_cfgs.
+          //
+          for (auto i (postponed_deps.begin ()); i != postponed_deps.end (); )
+          {
+            if (i->second.initial_collection)
+              i = postponed_deps.erase (i);
+            else
+              ++i;
+          }
 
-        // Add to the plan dependencies to up/down-grade/drop that were
-        // discovered on the previous iterations.
-        //
-        for (const dep& d: deps)
+          // Handle the (combined) postponed collection.
+          //
+          if (!postponed_repo.empty ()    ||
+              !postponed_alts.empty ()    ||
+              postponed_deps.has_bogus () ||
+              !postponed_cfgs.empty ())
+            pkgs.collect_build_postponed (o,
+                                          replaced_vers,
+                                          postponed_repo,
+                                          postponed_alts,
+                                          postponed_deps,
+                                          postponed_cfgs,
+                                          postponed_cfgs_history,
+                                          postponed_poss,
+                                          find_prereq_database,
+                                          rpt_depts,
+                                          add_priv_cfg);
+
+          // Erase the bogus replacements and re-collect from scratch, if any
+          // (see replaced_versions for details).
+          //
+          replaced_vers.cancel_bogus (trace, true /* scratch */);
+
+          // Erase the bogus existing dependent re-evaluation postponements
+          // and re-collect from scratch, if any (see postponed_positions for
+          // details).
+          //
+          postponed_poss.cancel_bogus (trace);
+        }
+        catch (const scratch_collection& e)
         {
-          database& ddb (d.db);
+          // Re-collect from scratch (but keep deps).
+          //
+          scratch_col = true;
 
-          if (d.available == nullptr)
-          {
-            pkgs.collect_drop (ddb, ddb.load<selected_package> (d.name));
-          }
-          else
-          {
-            shared_ptr<selected_package> sp (
-              ddb.find<selected_package> (d.name));
+          l5 ([&]{trace << "collection failed due to " << e.description
+                        << (e.package != nullptr
+                            ? " (" + e.package->string () + ")"
+                            : empty_string)
+                        << ", retry from scratch";});
 
-            // We will keep the output directory only if the external package
-            // is replaced with an external one (see above for details).
-            //
-            bool keep_out (o.keep_out () && sp->external ());
+          // Erase the package version replacements that we didn't apply
+          // during the current (re-)collection iteration since the dependents
+          // demanding this version are not collected anymore.
+          //
+          replaced_vers.cancel_bogus (trace, false /* scratch */);
 
-            // Marking upgraded dependencies as "required by command line" may
-            // seem redundant as they should already be pre-entered as such
-            // (see above). But remember dependencies upgraded with -i|-r?
-            // Note that the required_by data member should never be empty, as
-            // it is used in prompts/diagnostics.
-            //
-            build_package p {
-              build_package::build,
-              ddb,
-              move (sp),
-              d.available,
-              d.repository_fragment,
-              nullopt,                    // Dependencies.
-              nullopt,                    // Package skeleton.
-              nullopt,                    // Postponed dependency alternatives.
-              nullopt,                    // Hold package.
-              nullopt,                    // Hold version.
-              {},                         // Constraints.
-              d.system,
-              keep_out,
-              o.disfigure (),
-              false,                      // Configure-only.
-              nullopt,                    // Checkout root.
-              false,                      // Checkout purge.
-              strings (),                 // Configuration variables.
-              {config_package {mdb, ""}}, // Required by (command line).
-              false,                      // Required by dependents.
-              0};                         // State flags.
+          restore_repointed_dependents ();
 
-            build_package_refs dep_chain;
+          // Commit linking of private configurations that were potentially
+          // created during the collection of the package builds with their
+          // parent configurations.
+          //
+          t.commit ();
 
-            // Note: recursive.
-            //
-            pkgs.collect_build (o,
-                                move (p),
-                                find_prereq_database,
-                                rpt_depts,
-                                add_priv_cfg,
-                                &postponed_repo,
-                                &postponed_alts,
-                                &dep_chain);
-          }
+          continue;
         }
 
-        // Handle the (combined) postponed collection.
-        //
-        if (!postponed_repo.empty () || !postponed_alts.empty ())
-          pkgs.collect_build_postponed (o,
-                                        postponed_repo,
-                                        postponed_alts,
-                                        find_prereq_database,
-                                        rpt_depts,
-                                        add_priv_cfg);
-
         // Now that we have collected all the package versions that we need to
         // build, arrange them in the "dependency order", that is, with every
         // package on the list only possibly depending on the ones after
@@ -6826,6 +11137,22 @@ namespace bpkg
                       find_prereq_database,
                       false                 /* reorder */);
 
+        for (const postponed_configuration& cfg: postponed_cfgs)
+        {
+          for (const auto& d: cfg.dependents)
+          {
+            if (d.second.existing)
+            {
+              const package_key& p (d.first);
+
+              pkgs.order (p.db,
+                          p.name,
+                          nullopt /* buildtime */,
+                          find_prereq_database);
+            }
+          }
+        }
+
         // Collect and order all the dependents that we will need to
         // reconfigure because of the up/down-grades of packages that are now
         // on the list.
@@ -6863,36 +11190,14 @@ namespace bpkg
           }
         }
 
+#ifndef NDEBUG
+        pkgs.verify_ordering ();
+#endif
         // Now, as we are done with package builds collecting/ordering, erase
         // the replacements from the repointed dependents prerequisite sets
         // and persist the changes.
         //
-        for (auto& rd: rpt_depts)
-        {
-          database&           db (rd.first.db);
-          const package_name& nm (rd.first.name);
-
-          shared_ptr<selected_package> sp (db.load<selected_package> (nm));
-
-          for (const auto& prq: rd.second)
-          {
-            if (prq.second) // Prerequisite replacement?
-            {
-              const config_package& cp (prq.first);
-
-              size_t n (sp->prerequisites.erase (
-                        lazy_shared_ptr<selected_package> (cp.db, cp.name)));
-
-              // The selected package should always contain the prerequisite
-              // replacement at this time, so its removal should always
-              // succeed.
-              //
-              assert (n == 1);
-            }
-          }
-
-          db.update (sp);
-        }
+        restore_repointed_dependents ();
 
         // We are about to execute the plan on the database (but not on the
         // filesystem / actual packages). Save the session state for the
@@ -7034,7 +11339,7 @@ namespace bpkg
 
           if (s)
           {
-            scratch = true; // Rebuild the plan from scratch.
+            scratch_exe = true; // Rebuild the plan from scratch.
             i = deps.erase (i);
           }
           else
@@ -7052,13 +11357,13 @@ namespace bpkg
         //
         if (!changed && dep_pkgs.empty () && rec_pkgs.empty ())
         {
-          assert (!scratch); // No reason to change any previous decision.
+          assert (!scratch_exe); // No reason to change any previous decision.
 
           if (o.keep_unused () || o.no_refinement ())
             refine = false;
         }
 
-        if (!scratch && refine)
+        if (!scratch_exe && refine)
         {
           // First, we check if the refinement is required, ignoring the
           // unsatisfiable dependency version constraints. If we end up
@@ -7152,7 +11457,7 @@ namespace bpkg
           using prerequisites = set<lazy_shared_ptr<selected_package>,
                                     compare_lazy_ptr_id>;
 
-          map<config_package, prerequisites> package_prereqs;
+          map<package_key, prerequisites> package_prereqs;
           small_vector<config_selected_package, 16> chain;
 
           auto verify_dependencies = [&package_prereqs, &chain]
@@ -7163,9 +11468,9 @@ namespace bpkg
           {
             // Return the cached value, if present.
             //
-            config_package cp {db, sp->name};
+            package_key pk {db, sp->name};
             {
-              auto i (package_prereqs.find (cp));
+              auto i (package_prereqs.find (pk));
 
               if (i != package_prereqs.end ())
                 return i->second;
@@ -7208,15 +11513,15 @@ namespace bpkg
             //
             // Note, however, that we cannot easily determine if the
             // prerequisite corresponds to the runtime or build-time
-            // dependency, since we only store its version constraint. The
-            // current implementation relies on the fact that the build-time
-            // dependency configuration type (host or build2) differs from the
-            // dependent configuration type (target is a common case) and
-            // doesn't work well, for example, for the self-hosted
-            // configurations. For them it can fail erroneously. We can
-            // potentially fix that by additionally storing the build-time
-            // flag besides the version constraint. However, let's first see
-            // if it ever becomes a problem.
+            // dependency, since we don't store this information for
+            // prerequisites. The current implementation relies on the fact
+            // that the build-time dependency configuration type (host or
+            // build2) differs from the dependent configuration type (target
+            // is a common case) and doesn't work well, for example, for the
+            // self-hosted configurations. For them it can fail
+            // erroneously. We can potentially fix that by additionally
+            // storing the build-time flag for a prerequisite. However, let's
+            // first see if it ever becomes a problem.
             //
             prerequisites r;
             const package_prerequisites& prereqs (sp->prerequisites);
@@ -7275,7 +11580,7 @@ namespace bpkg
             // Cache the resulting package prerequisites set and return a
             // reference to it.
             //
-            auto j (package_prereqs.emplace (move (cp), move (r)));
+            auto j (package_prereqs.emplace (move (pk), move (r)));
             assert (j.second); // A package cannot depend on itself.
 
             return j.first->second;
@@ -7298,22 +11603,22 @@ namespace bpkg
             // List of module packages together with the linked configuration
             // clusters they belong to.
             //
-            vector<pair<config_package, linked_databases>> build2_mods;
+            vector<pair<package_key, linked_databases>> build2_mods;
 
             for (const auto& pp: package_prereqs)
             {
-              const config_package& cp (pp.first);
+              const package_key& pk (pp.first);
 
               // Skip packages other than the build2 modules.
               //
-              if (!build2_module (cp.name))
+              if (!build2_module (pk.name))
                 continue;
 
               // Skip build2 modules configured as system.
               //
               {
                 shared_ptr<selected_package> sp (
-                  cp.db.find<selected_package> (cp.name));
+                  pk.db.get ().find<selected_package> (pk.name));
 
                 assert (sp != nullptr);
 
@@ -7326,28 +11631,28 @@ namespace bpkg
               //
               for (const auto& m: build2_mods)
               {
-                if (m.first.name != cp.name)
+                if (m.first.name != pk.name)
                   continue;
 
                 // The `package_prereqs` map can only contain the same package
                 // twice if databases differ.
                 //
-                assert (m.first.db != cp.db);
+                assert (m.first.db != pk.db);
 
                 const linked_databases& lcc (m.second);
 
-                if (find (lcc.begin (), lcc.end (), cp.db) != lcc.end ())
+                if (find (lcc.begin (), lcc.end (), pk.db) != lcc.end ())
                 {
-                  fail << "building build system module " << cp.name
+                  fail << "building build system module " << pk.name
                        << " in multiple configurations" <<
-                    info << m.first.db.config_orig <<
-                    info << cp.db.config_orig;
+                    info << m.first.db.get ().config_orig <<
+                    info << pk.db.get ().config_orig;
                 }
               }
 
               // Add the module and its cluster to the list.
               //
-              build2_mods.emplace_back (cp, cp.db.cluster_configs ());
+              build2_mods.emplace_back (pk, pk.db.get ().cluster_configs ());
             }
           }
         }
@@ -7507,6 +11812,13 @@ namespace bpkg
     // While at it, detect if we have any dependents that the user may want to
     // update.
     //
+    // For the packages being printed also print the configuration specified
+    // by the user, dependents, and via the reflect clauses. For that we will
+    // use the package skeletons, initializing them if required. Note that for
+    // a system package the skeleton may already be initialized during the
+    // dependency negotiation process. Also note that the freshly-initialized
+    // skeletons will be reused during the plan execution.
+    //
     bool update_dependents (false);
 
     // We need the plan and to ask for the user's confirmation only if some
@@ -7524,17 +11836,22 @@ namespace bpkg
         o.plan_specified () ||
         o.rebuild_checksum_specified ())
     {
+      // Start the transaction since we may query available packages for
+      // skeleton initializations.
+      //
+      transaction t (mdb);
+
       bool first (true); // First entry in the plan.
 
-      for (const build_package& p: reverse_iterate (pkgs))
+      for (build_package& p: reverse_iterate (pkgs))
       {
+        assert (p.action);
+
         database& pdb (p.db);
         const shared_ptr<selected_package>& sp (p.selected);
 
         string act;
 
-        assert (p.action);
-
         if (*p.action == build_package::drop)
         {
           act = "drop " + sp->string (pdb) + " (unused)";
@@ -7542,6 +11859,13 @@ namespace bpkg
         }
         else
         {
+          // Print configuration variables.
+          //
+          // The idea here is to only print configuration for those packages
+          // for which we call pkg_configure*() in execute_plan().
+          //
+          package_skeleton* cfg (nullptr);
+
           string cause;
           if (*p.action == build_package::adjust)
           {
@@ -7577,14 +11901,43 @@ namespace bpkg
             const string& s (pdb.string);
             if (!s.empty ())
               act += ' ' + s;
+
+            // This is an adjustment and so there is no available package
+            // specified for the build package object and thus the skeleton
+            // cannot be present.
+            //
+            assert (p.available == nullptr && !p.skeleton);
+
+            // We shouldn't be printing configurations for plain unholds.
+            //
+            if (p.reconfigure ())
+            {
+              // Since there is no available package specified we need to find
+              // it (or create a transient one).
+              //
+              cfg = &p.init_skeleton (o, find_available (o, pdb, sp));
+            }
           }
           else
           {
+            assert (p.available != nullptr); // This is a package build.
+
             // Even if we already have this package selected, we have to
             // make sure it is configured and updated.
             //
             if (sp == nullptr)
+            {
               act = p.system ? "configure" : "new";
+
+              // For a new non-system package the skeleton must already be
+              // initialized.
+              //
+              assert (p.system || p.skeleton.has_value ());
+
+              // Initialize the skeleton if it is not initialized yet.
+              //
+              cfg = &(p.skeleton ? *p.skeleton : p.init_skeleton (o));
+            }
             else if (sp->version == p.available_version ())
             {
               // If this package is already configured and is not part of the
@@ -7606,6 +11959,13 @@ namespace bpkg
                       ? "reconfigure"
                       : "reconfigure/update")
                    : "update");
+
+              if (p.reconfigure ())
+              {
+                // Initialize the skeleton if it is not initialized yet.
+                //
+                cfg = &(p.skeleton ? *p.skeleton : p.init_skeleton (o));
+              }
             }
             else
             {
@@ -7615,6 +11975,15 @@ namespace bpkg
                   ? "upgrade"
                   : "downgrade";
 
+              // For a non-system package up/downgrade the skeleton must
+              // already be initialized.
+              //
+              assert (p.system || p.skeleton.has_value ());
+
+              // Initialize the skeleton if it is not initialized yet.
+              //
+              cfg = &(p.skeleton ? *p.skeleton : p.init_skeleton (o));
+
               need_prompt = true;
             }
 
@@ -7637,8 +12006,8 @@ namespace bpkg
             // dependent-dependency structure change without any of the
             // package versions changing? Doesn't feel like it should.
             //
-            for (const config_package& cp: p.required_by)
-              rb += (rb.empty () ? " " : ", ") + cp.string ();
+            for (const package_key& pk: p.required_by)
+              rb += (rb.empty () ? " " : ", ") + pk.string ();
 
             // If not user-selected, then there should be another (implicit)
             // reason for the action.
@@ -7650,6 +12019,14 @@ namespace bpkg
 
           if (!rb.empty ())
             act += " (" + cause + rb + ')';
+
+          if (cfg != nullptr && !cfg->empty_print ())
+          {
+            ostringstream os;
+            cfg->print_config (os, o.print_only () ? "  " : "    ");
+            act += '\n';
+            act += os.str ();
+          }
         }
 
         if (first)
@@ -7677,6 +12054,8 @@ namespace bpkg
         if (o.rebuild_checksum_specified ())
           csum.append (act);
       }
+
+      t.commit ();
     }
 
     if (o.rebuild_checksum_specified ())
@@ -7882,7 +12261,7 @@ namespace bpkg
       }
 
       if (*p.action != build_package::drop &&
-          !p.skeleton                      &&
+          !p.dependencies                  &&
           !sp->prerequisites.empty ())
       {
         vector<package_name>& ps (previous_prerequisites[&p]);
@@ -7913,7 +12292,6 @@ namespace bpkg
       assert (sp->state == package_state::unpacked ||
               sp->state == package_state::transient);
 
-
       if (result || progress)
       {
         const char* what (sp->state == package_state::transient
@@ -8280,6 +12658,9 @@ namespace bpkg
       // source code one, or just available, in which case it is a system
       // one. Note that a system package gets selected as being configured.
       //
+      // NOTE: remember to update the preparation of the plan to be presented
+      // to the user if changing anything here.
+      //
       assert (sp != nullptr || p.system);
 
       database& pdb (p.db);
@@ -8314,9 +12695,11 @@ namespace bpkg
       }
       else if (ap != nullptr)
       {
+        assert (*p.action == build_package::build);
+
         // If the package prerequisites builds are collected, then use the
-        // resulting package skeleton and dependency list for optimization
-        // (not to re-evaluate enable conditions, etc).
+        // resulting package skeleton and the pre-selected dependency
+        // alternatives.
         //
         // Note that we may not collect the package prerequisites builds if
         // the package is already configured but we still need to reconfigure
@@ -8333,17 +12716,19 @@ namespace bpkg
         //    the package manually). Maybe that a good reason not to allow
         //    this? Or we could store this information in the database.
         //
-        if (p.skeleton)
+        if (p.dependencies)
         {
-          assert (p.dependencies);
+          assert (p.skeleton);
 
           pkg_configure (o,
                          pdb,
                          t,
                          sp,
                          *p.dependencies,
+                         &*p.alternatives,
                          move (*p.skeleton),
                          nullptr /* previous_prerequisites */,
+                         p.disfigure,
                          simulate,
                          fdb);
         }
@@ -8351,85 +12736,77 @@ namespace bpkg
         {
           assert (sp != nullptr); // See above.
 
-          optional<dir_path> src_root (p.external_dir ());
-
-          optional<dir_path> out_root (
-            src_root && !p.disfigure
-            ? dir_path (pdb.config) /= p.name ().string ()
-            : optional<dir_path> ());
+          // Note that the skeleton can be present if, for example, this is a
+          // dependency which configuration has been negotiated but it is not
+          // collected recursively since it has no buildfile clauses.
+          //
+          if (!p.skeleton)
+            p.init_skeleton (o);
 
           pkg_configure (o,
                          pdb,
                          t,
                          sp,
                          ap->dependencies,
-                         package_skeleton (o,
-                                           pdb,
-                                           *ap,
-                                           move (p.config_vars),
-                                           move (src_root),
-                                           move (out_root)),
+                         nullptr /* alternatives */,
+                         move (*p.skeleton),
                          prereqs (),
+                         p.disfigure,
                          simulate,
                          fdb);
         }
       }
       else // Dependent.
       {
+        // This is an adjustment of a dependent which cannot be system
+        // (otherwise it wouldn't be a dependent) and cannot become system
+        // (otherwise it would be a build).
+        //
+        assert (*p.action == build_package::adjust &&
+                !p.system &&
+                !sp->system ());
+
         // Must be in the unpacked state since it was disfigured on the first
         // pass (see above).
         //
         assert (sp->state == package_state::unpacked);
 
-        // First try to avoid the package manifest parsing, searching for an
-        // existing available package for the selected package and, if not
-        // found, create a transient one.
+        // Initialize the skeleton if it is not initialized yet.
         //
-        // Note that we don't use find_available*() here since we don't care
-        // about the repository fragment the package comes from and only need
-        // its manifest information.
+        // Note that the skeleton can only be present here if it was
+        // initialized during the preparation of the plan and so this plan
+        // execution is not simulated (see above for details).
         //
-        shared_ptr<available_package> dap;
-
-        available_package_id pid (sp->name, sp->version);
-        for (database& db: dependent_repo_configs (pdb))
-        {
-          shared_ptr<available_package> ap (db.find<available_package> (pid));
-
-          if (ap != nullptr && !ap->stub ())
-          {
-            dap = move (ap);
-            break;
-          }
-        }
+        // Also note that there is no available package specified for the
+        // build package object here and so we need to find it (or create a
+        // transient one).
+        //
+        assert (p.available == nullptr && (!p.skeleton || !simulate));
 
-        if (dap == nullptr)
-          dap = make_available (o, pdb, sp);
+        if (!p.skeleton)
+          p.init_skeleton (o, find_available (o, pdb, sp));
 
-        optional<dir_path> src_root (p.external_dir ());
+        assert (p.skeleton->available != nullptr); // Can't be system.
 
-        optional<dir_path> out_root (
-          src_root && !p.disfigure
-          ? dir_path (pdb.config) /= p.name ().string ()
-          : optional<dir_path> ());
+        const dependencies& deps (p.skeleton->available->dependencies);
 
         // @@ Note that on reconfiguration the dependent looses the potential
         //    configuration variables specified by the user on some previous
         //    build, which can be quite surprising. Should we store this
         //    information in the database?
         //
+        //    I believe this now works for external packages via package
+        //    skeleton (which extracts user configuration).
+        //
         pkg_configure (o,
                        pdb,
                        t,
                        sp,
-                       dap->dependencies,
-                       package_skeleton (o,
-                                         pdb,
-                                         *dap,
-                                         move (p.config_vars),
-                                         move (src_root),
-                                         move (out_root)),
+                       deps,
+                       nullptr /* alternatives */,
+                       move (*p.skeleton),
                        prereqs (),
+                       false /* disfigured */,
                        simulate,
                        fdb);
       }
diff --git a/bpkg/pkg-configure.cxx b/bpkg/pkg-configure.cxx
index 1392545..a86752e 100644
--- a/bpkg/pkg-configure.cxx
+++ b/bpkg/pkg-configure.cxx
@@ -36,7 +36,7 @@ namespace bpkg
     // package skeleton, excluding those user-specified variables which are
     // not the project variables for the specified package (module
     // configuration variables, etc). Thus, it is not parallel to the
-    // variables member.
+    // config_variables member.
     //
     vector<config_variable> config_sources; // Note: name and source.
   };
@@ -48,14 +48,19 @@ namespace bpkg
                                database& db,
                                transaction&,
                                const dependencies& deps,
+                               const vector<size_t>* alts,
                                package_skeleton&& ps,
                                const vector<package_name>* prev_prereqs,
                                bool simulate,
                                const function<find_database_function>& fdb)
   {
-    package_prerequisites   prereqs;
-    strings                 vars;
-    vector<config_variable> srcs;
+    package_prerequisites prereqs;
+    strings               vars;
+
+    // Alternatives argument must be parallel to the dependencies argument if
+    // specified.
+    //
+    assert (alts == nullptr || alts->size () == deps.size ());
 
     for (size_t di (0); di != deps.size (); ++di)
     {
@@ -64,19 +69,55 @@ namespace bpkg
       //
       const dependency_alternatives_ex& das (deps[di]);
 
-      if (das.empty () || toolchain_buildtime_dependency (o, das, ps.name ()))
+      if (das.empty ())
         continue;
 
-      small_vector<reference_wrapper<const dependency_alternative>, 2> edas;
+      small_vector<pair<reference_wrapper<const dependency_alternative>,
+                        size_t>,
+                   2> edas;
 
-      for (const dependency_alternative& da: das)
+      // If the dependency alternatives are not pre-selected, then evaluate
+      // the enable clauses.
+      //
+      // Note that evaluating the require and prefer clauses in this case is
+      // meaningless since we don't reconfigure the dependencies nor negotiate
+      // configurations with other dependents. What we should probably do is
+      // load configurations of the dependencies and use them while evaluating
+      // the dependent's enable and reflect clauses as we go along. Probably
+      // we should still evaluate the accept clauses to make sure that the
+      // dependency is configured acceptably for the dependent. For now we
+      // fail and will support this maybe later.
+      //
+      if (alts == nullptr)
       {
-        if (!da.enable || ps.evaluate_enable (*da.enable, di))
-          edas.push_back (da);
+        if (toolchain_buildtime_dependency (o, das, &ps.package.name))
+          continue;
+
+        for (size_t i (0); i != das.size (); ++i)
+        {
+          const dependency_alternative& da (das[i]);
+
+          if (!da.enable || ps.evaluate_enable (*da.enable, make_pair (di, i)))
+          {
+            if (da.prefer || da.require)
+              fail << "manual configuration of dependents with prefer or "
+                   << "require clauses is not yet supported";
+
+            edas.push_back (make_pair (ref (da), i));
+          }
+        }
+
+        if (edas.empty ())
+          continue;
       }
+      else
+      {
+        // Must only contain the selected alternative.
+        //
+        assert (das.size () == 1);
 
-      if (edas.empty ())
-        continue;
+        edas.push_back (make_pair (ref (das.front ()), (*alts)[di]));
+      }
 
       // Pick the first alternative with dependencies that can all be resolved
       // to the configured packages, satisfying the respective constraints.
@@ -91,16 +132,19 @@ namespace bpkg
       for (const vector<package_name>* pps (prev_prereqs);;)
       {
         bool satisfied (false);
-        for (const dependency_alternative& da: edas)
+        for (const auto& eda: edas)
         {
+          const dependency_alternative& da (eda.first);
+          size_t dai (eda.second);
+
           // Cache the selected packages which correspond to the alternative
           // dependencies, pairing them with the respective constraints. If
           // the alternative turns out to be fully resolvable, we will add the
           // cached packages into the dependent's prerequisites map.
           //
           small_vector<
-            pair<lazy_shared_ptr<selected_package>,
-                 const optional<version_constraint>&>, 1> prerequisites;
+            pair<lazy_shared_ptr<selected_package>, prerequisite_info>,
+            1> prerequisites;
 
           dependency_alternative::const_iterator b (da.begin ());
           dependency_alternative::const_iterator i (b);
@@ -132,9 +176,13 @@ namespace bpkg
             // See the package_prerequisites definition for details on
             // creating the map keys with the database passed.
             //
+            bool conf (da.prefer || da.require);
+
             prerequisites.emplace_back (
               lazy_shared_ptr<selected_package> (*spd.second, dp),
-              d.constraint);
+              prerequisite_info {d.constraint,
+                                 make_pair (conf ? di  + 1 : 0,
+                                            conf ? dai + 1 : 0)});
           }
 
           // Try the next alternative if there are unresolved dependencies for
@@ -150,9 +198,9 @@ namespace bpkg
           for (auto& pr: prerequisites)
           {
             const package_name& pn (pr.first.object_id ());
-            const optional<version_constraint>& pc (pr.second);
+            const prerequisite_info& pi (pr.second);
 
-            auto p (prereqs.emplace (pr.first, pc));
+            auto p (prereqs.emplace (pr.first, pi));
 
             // Currently we can only capture a single constraint, so if we
             // already have a dependency on this package and one constraint is
@@ -160,18 +208,28 @@ namespace bpkg
             //
             if (!p.second)
             {
-              auto& c (p.first->second);
+              auto& c1 (p.first->second.constraint);
+              auto& c2 (pi.constraint);
 
-              bool s1 (satisfies (c, pc));
-              bool s2 (satisfies (pc, c));
+              bool s1 (satisfies (c1, c2));
+              bool s2 (satisfies (c2, c1));
 
               if (!s1 && !s2)
                 fail << "multiple dependencies on package " << pn <<
-                  info << pn << " " << *c <<
-                  info << pn << " " << *pc;
+                  info << pn << " " << *c1 <<
+                  info << pn << " " << *c2;
 
               if (s2 && !s1)
-                c = pc;
+                c1 = c2;
+
+              // Keep position of the first dependency alternative with a
+              // configuration clause.
+              //
+              pair<size_t, size_t>& p1 (p.first->second.config_position);
+              pair<size_t, size_t>  p2 (pi.config_position);
+
+              if (p1.first == 0 && p2.first != 0)
+                p1 = p2;
             }
 
             // If the prerequisite is configured in the linked configuration,
@@ -215,7 +273,7 @@ namespace bpkg
           // Evaluate the dependency alternative reflect clause, if present.
           //
           if (da.reflect)
-            ps.evaluate_reflect (*da.reflect, di);
+            ps.evaluate_reflect (*da.reflect, make_pair (di, dai));
 
           satisfied = true;
           break;
@@ -244,34 +302,28 @@ namespace bpkg
       }
     }
 
-    // Add the configuration variables collected from the reflect clauses, if
-    // any.
+    // Add the rest of the configuration variables (user overrides, reflects,
+    // etc) as well as their sources.
     //
+    vector<config_variable> srcs;
+
     if (!simulate)
     {
-      auto rvs (move (ps).collect_config ());
+      pair<strings, vector<config_variable>> rvs (move (ps).collect_config ());
 
-      strings&                         vs (rvs.first);
-      vector<optional<config_source>>& ss (rvs.second);
+      strings& vs (rvs.first);
+      srcs = move (rvs.second);
 
       if (!vs.empty ())
       {
-        vars.reserve (vars.size () + vs.size ());
-
-        for (size_t i (0); i != vs.size (); ++i)
+        if (vars.empty ())
+          vars = move (vs);
+        else
         {
-          string&                        v (vs[i]);
-          const optional<config_source>& s (ss[i]);
-
-          if (s)
-          {
-            size_t p (v.find_first_of ("=+ \t"));
-            assert (p != string::npos);
-
-            srcs.push_back (config_variable {string (v, 0, p), *s});
-          }
+          vars.reserve (vars.size () + vs.size ());
 
-          vars.push_back (move (v));
+          for (string& v: vs)
+            vars.push_back (move (v));
         }
       }
     }
@@ -287,8 +339,10 @@ namespace bpkg
                  transaction& t,
                  const shared_ptr<selected_package>& p,
                  const dependencies& deps,
+                 const vector<size_t>* alts,
                  package_skeleton&& ps,
                  const vector<package_name>* pps,
+                 bool disfigured,
                  bool simulate,
                  const function<find_database_function>& fdb)
   {
@@ -322,6 +376,7 @@ namespace bpkg
                                    db,
                                    t,
                                    deps,
+                                   alts,
                                    move (ps),
                                    pps,
                                    simulate,
@@ -346,31 +401,26 @@ namespace bpkg
 
       l4 ([&]{trace << "buildspec: " << bspec;});
 
-      // Deduce the configuration variables which are not reflected anymore
-      // and disfigure them.
+      // Unless this package has been completely disfigured, disfigure all the
+      // package configuration variables to reset all the old values to
+      // defaults (all the new user/dependent/reflec values, including old
+      // user, are returned by collect_config() and specified as overrides).
+      // Note that this semantics must be consistent with how we load things
+      // in the package skeleton during configuration negotiation.
+      //
+      // Note also that this means we don't really use the dependent and
+      // reflect sources that we save in the database. But let's keep them
+      // for the completeness of information (maybe could be useful during
+      // configuration reset or some such).
       //
       string dvar;
-      for (const config_variable& cv: p->config_variables)
+      if (!disfigured)
       {
-        if (cv.source == config_source::reflect)
-        {
-          const vector<config_variable>& ss (cpr.config_sources);
-          auto i (find_if (ss.begin (), ss.end (),
-                           [&cv] (const config_variable& v)
-                           {
-                             return v.name == cv.name;
-                           }));
-
-          if (i == ss.end ())
-          {
-            if (dvar.empty ())
-              dvar = "config.config.disfigure=";
-            else
-              dvar += ' ';
-
-            dvar += cv.name;
-          }
-        }
+        // Note: must be quoted to preserve the pattern.
+        //
+        dvar = "config.config.disfigure='config.";
+        dvar += p->name.variable ();
+        dvar += "**'";
       }
 
       // Configure.
@@ -554,18 +604,30 @@ namespace bpkg
                                    ? dir_path (db.config) /= p->name.string ()
                                    : optional<dir_path> ());
 
+      // Note on the disfigure logic: while we don't know whether the package
+      // has been disfigured with --keep-config or not, it has already been
+      // done physically and if without --keep-config, then config.build has
+      // been removed and config_variables cleaned. As a result, we can just
+      // proceed as disfigure=false and disfigure=true will be taken care
+      // automatically (because then things have been removed/cleaned).
+      //
       pkg_configure (o,
                      db,
                      t,
                      p,
                      ap->dependencies,
+                     nullptr /* alternatives */,
                      package_skeleton (o,
-                                       db,
-                                       *ap,
+                                       package_key (db, ap->id.name),
+                                       false /* system */,
+                                       ap,
                                        move (vars),
+                                       false /* disfigure */,
+                                       &p->config_variables,
                                        move (src_root),
                                        move (out_root)),
                      nullptr /* prerequisites */,
+                     false /* disfigured */,
                      false /* simulate */);
     }
 
diff --git a/bpkg/pkg-configure.hxx b/bpkg/pkg-configure.hxx
index 23dab83..16ed96f 100644
--- a/bpkg/pkg-configure.hxx
+++ b/bpkg/pkg-configure.hxx
@@ -33,9 +33,16 @@ namespace bpkg
 
   // Configure the package, update its state, and commit the transaction.
   //
-  // The package dependency constraints are expected to be complete. Empty
-  // dependency alternatives lists are allowed and are ignored (see pkg-build
-  // for the use-case).
+  // The package dependency constraints are expected to be complete.
+  //
+  // The dependencies argument may contain pre-selected dependency
+  // alternatives (with the potential empty entries for the toolchain
+  // build-time dependencies or for dependencies with all the alternatives
+  // disabled; see pkg-build for the use-case). In this case the number of
+  // dependency alternatives for each dependency must be 1 (or 0) and the
+  // alternatives argument must be specified. The alternatives argument must
+  // be parallel to the dependencies argument and specify indexes of the
+  // selected alternatives.
   //
   // If prerequisites corresponding to the previous configured state of the
   // package are specified, then for each depends value try to select an
@@ -49,8 +56,10 @@ namespace bpkg
                  transaction&,
                  const shared_ptr<selected_package>&,
                  const dependencies&,
+                 const vector<size_t>* alternatives,
                  package_skeleton&&,
                  const vector<package_name>* prerequisites,
+                 bool disfigured,
                  bool simulate,
                  const function<find_database_function>& = {});
 
diff --git a/bpkg/pkg-drop.cxx b/bpkg/pkg-drop.cxx
index 08168d4..0aadaa7 100644
--- a/bpkg/pkg-drop.cxx
+++ b/bpkg/pkg-drop.cxx
@@ -77,7 +77,7 @@ namespace bpkg
              drop_reason r = drop_reason::user)
     {
       package_name n (p->name); // Because of move(p) below.
-      return map_.emplace (config_package {db, move (n)},
+      return map_.emplace (package_key {db, move (n)},
                            data_type {end (), {db, move (p), r}}).second;
     }
 
@@ -278,7 +278,7 @@ namespace bpkg
           if (!keep)
           {
             i = erase (i);
-            map_.erase (config_package {db, p->name});
+            map_.erase (package_key {db, p->name});
             continue;
           }
 
@@ -298,18 +298,18 @@ namespace bpkg
       drop_package package;
     };
 
-    class config_package_map: public map<config_package, data_type>
+    class package_map: public map<package_key, data_type>
     {
     public:
-      using base_type = map<config_package, data_type>;
+      using base_type = map<package_key, data_type>;
 
       iterator
       find (database& db, const package_name& pn)
       {
-        return base_type::find (config_package {db, pn});
+        return base_type::find (package_key {db, pn});
       }
     };
-    config_package_map map_;
+    package_map map_;
   };
 
   // Drop ordered list of packages.
diff --git a/bpkg/pkg-fetch.cxx b/bpkg/pkg-fetch.cxx
index 531bf84..d065ff1 100644
--- a/bpkg/pkg-fetch.cxx
+++ b/bpkg/pkg-fetch.cxx
@@ -256,12 +256,12 @@ namespace bpkg
       //
       assert (ap->sha256sum);
 
-      const string& sha256sum (sha256 (co, a));
-      if (sha256sum != *ap->sha256sum)
+      const string& cs (sha256sum (co, a));
+      if (cs != *ap->sha256sum)
       {
         fail << "checksum mismatch for " << n << " " << v <<
           info << pl->repository_fragment->name << " has " << *ap->sha256sum <<
-          info << "fetched archive has " << sha256sum <<
+          info << "fetched archive has " << cs <<
           info << "consider re-fetching package list and trying again" <<
           info << "if problem persists, consider reporting this to "
                << "the repository maintainer";
diff --git a/bpkg/pkg-status.cxx b/bpkg/pkg-status.cxx
index 45ea519..09a9424 100644
--- a/bpkg/pkg-status.cxx
+++ b/bpkg/pkg-status.cxx
@@ -144,7 +144,7 @@ namespace bpkg
     {
       shared_ptr<selected_package> d (pair.first.load ());
       database& db (pair.first.database ());
-      const optional<version_constraint>& c (pair.second);
+      const optional<version_constraint>& c (pair.second.constraint);
       r.push_back (package {db, rdb, d->name, version (), move (d), c});
     }
     return r;
diff --git a/bpkg/rep-create.cxx b/bpkg/rep-create.cxx
index b4944b7..c9ee924 100644
--- a/bpkg/rep-create.cxx
+++ b/bpkg/rep-create.cxx
@@ -24,7 +24,7 @@ using namespace butl;
 
 namespace bpkg
 {
-  struct package_key
+  struct package_version_key
   {
     package_name name;
     bpkg::version version;
@@ -34,20 +34,20 @@ namespace bpkg
     // revision.
     //
     bool
-    operator< (const package_key& y) const
+    operator< (const package_version_key& y) const
     {
       int r (name.compare (y.name));
       return r < 0 || (r == 0 && version.compare (y.version, true) < 0);
     }
   };
 
-  struct package_data
+  struct package_version_data
   {
     path archive;
     package_manifest manifest;
   };
 
-  using package_map = map<package_key, package_data>;
+  using package_map = map<package_version_key, package_version_data>;
 
   static void
   collect (const rep_create_options& o,
@@ -106,7 +106,7 @@ namespace bpkg
 
       // Calculate its checksum.
       //
-      m.sha256sum = sha256 (o, a);
+      m.sha256sum = sha256sum (o, a);
 
       l4 ([&]{trace << m.name << " " << m.version << " in " << a
                     << " sha256sum " << *m.sha256sum;});
@@ -115,8 +115,8 @@ namespace bpkg
       //
       m.location = a.leaf (root);
 
-      package_key k {m.name, m.version}; // Argument evaluation order.
-      auto r (map.emplace (move (k), package_data {a, move (m)}));
+      package_version_key k {m.name, m.version}; // Argument evaluation order.
+      auto r (map.emplace (move (k), package_version_data {a, move (m)}));
 
       // Diagnose duplicates.
       //
@@ -183,7 +183,7 @@ namespace bpkg
     collect (o, pm, d, d);
 
     pkg_package_manifests manifests;
-    manifests.sha256sum = sha256 (o, path (d / repositories_file));
+    manifests.sha256sum = sha256sum (o, path (d / repositories_file));
 
     for (auto& p: pm)
     {
@@ -235,7 +235,7 @@ namespace bpkg
             info << "run 'bpkg help rep-create' for more information";
 
         signature_manifest m;
-        m.sha256sum = sha256 (o, p);
+        m.sha256sum = sha256sum (o, p);
         m.signature = sign_repository (o, m.sha256sum, key, *cert, d);
 
         p = path (d / signature_file);
diff --git a/bpkg/rep-info.cxx b/bpkg/rep-info.cxx
index 5184048..7d78173 100644
--- a/bpkg/rep-info.cxx
+++ b/bpkg/rep-info.cxx
@@ -5,7 +5,6 @@
 
 #include <iostream> // cout
 
-#include <libbutl/sha256.hxx>              // sha256_to_fingerprint()
 #include <libbutl/manifest-serializer.hxx>
 
 #include <libbpkg/manifest.hxx>
diff --git a/bpkg/types.hxx b/bpkg/types.hxx
index a8cd0f4..2b6a1f8 100644
--- a/bpkg/types.hxx
+++ b/bpkg/types.hxx
@@ -26,6 +26,7 @@
 #include <libbutl/path.hxx>
 #include <libbutl/uuid.hxx>
 #include <libbutl/uuid-io.hxx>
+#include <libbutl/sha256.hxx>
 #include <libbutl/process.hxx>
 #include <libbutl/utility.hxx>         // icase_compare_string,
                                        // compare_reference_target
@@ -103,6 +104,12 @@ namespace bpkg
   //
   using butl::url;
 
+  // <libbutl/sha256.hxx>
+  //
+  using butl::sha256;
+  using butl::sha256_to_fingerprint;
+  using butl::fingerprint_to_sha256;
+
   // <libbutl/process.hxx>
   //
   using butl::process;
diff --git a/bpkg/utility.hxx b/bpkg/utility.hxx
index 2dcf46d..597800c 100644
--- a/bpkg/utility.hxx
+++ b/bpkg/utility.hxx
@@ -48,6 +48,10 @@ namespace bpkg
   using butl::digit;
   using butl::xdigit;
 
+  using butl::trim;
+  using butl::trim_left;
+  using butl::trim_right;
+
   using butl::make_guard;
   using butl::make_exception_guard;
 
diff --git a/tests/common/dependency-alternatives/t11a/bac-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/bac-1.0.0.tar.gz
new file mode 100644
index 0000000..7a7670d
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/bac-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/bar-0.1.0.tar.gz b/tests/common/dependency-alternatives/t11a/bar-0.1.0.tar.gz
new file mode 100644
index 0000000..34774a8
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/bar-0.1.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..15d819e
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/bas-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/bas-1.0.0.tar.gz
new file mode 100644
index 0000000..c6365e3
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/bas-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/bat-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/bat-1.0.0.tar.gz
new file mode 100644
index 0000000..bb92104
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/bat-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/bax-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/bax-1.0.0.tar.gz
new file mode 100644
index 0000000..d488f1a
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/bax-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/baz-0.1.0.tar.gz b/tests/common/dependency-alternatives/t11a/baz-0.1.0.tar.gz
new file mode 100644
index 0000000..a1f37b0
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/baz-0.1.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..1fd57fe
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/bex-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/bex-1.0.0.tar.gz
new file mode 100644
index 0000000..4afa0f8
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/bex-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/bix-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/bix-1.0.0.tar.gz
new file mode 100644
index 0000000..2109914
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/bix-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/biz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/biz-1.0.0.tar.gz
new file mode 100644
index 0000000..e81a027
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/biz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/boo-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/boo-1.0.0.tar.gz
new file mode 100644
index 0000000..778b253
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/boo-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/box-0.1.0.tar.gz b/tests/common/dependency-alternatives/t11a/box-0.1.0.tar.gz
new file mode 100644
index 0000000..8e91f91
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/box-0.1.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/box-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/box-1.0.0.tar.gz
new file mode 100644
index 0000000..d205dc1
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/box-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/buc-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/buc-1.0.0.tar.gz
new file mode 100644
index 0000000..88183f7
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/buc-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/bus-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/bus-1.0.0.tar.gz
new file mode 100644
index 0000000..1530f14
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/bus-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/bux-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/bux-1.0.0.tar.gz
new file mode 100644
index 0000000..210941a
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/bux-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/buz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/buz-1.0.0.tar.gz
new file mode 100644
index 0000000..7419d8a
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/buz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/dex-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/dex-1.0.0.tar.gz
new file mode 100644
index 0000000..58bb16d
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/dex-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/dix-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/dix-1.0.0.tar.gz
new file mode 100644
index 0000000..2236190
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/dix-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/diz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/diz-1.0.0.tar.gz
new file mode 100644
index 0000000..a7fc8fa
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/diz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/dox-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/dox-1.0.0.tar.gz
new file mode 100644
index 0000000..00c730a
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/dox-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/fex-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/fex-1.0.0.tar.gz
new file mode 100644
index 0000000..00e925a
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/fex-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/fix-0.1.0.tar.gz b/tests/common/dependency-alternatives/t11a/fix-0.1.0.tar.gz
new file mode 100644
index 0000000..1d4ab42
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/fix-0.1.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/fix-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/fix-1.0.0.tar.gz
new file mode 100644
index 0000000..3613136
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/fix-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/foo-0.1.0.tar.gz b/tests/common/dependency-alternatives/t11a/foo-0.1.0.tar.gz
new file mode 100644
index 0000000..ebf3f01
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/foo-0.1.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/foo-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/foo-1.0.0.tar.gz
new file mode 100644
index 0000000..c9a4d6d
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/foo-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/fox-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/fox-1.0.0.tar.gz
new file mode 100644
index 0000000..17b7278
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/fox-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/fux-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/fux-1.0.0.tar.gz
new file mode 100644
index 0000000..b045fcd
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/fux-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/libbar-0.1.0.tar.gz b/tests/common/dependency-alternatives/t11a/libbar-0.1.0.tar.gz
new file mode 100644
index 0000000..57b9ccc
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/libbar-0.1.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/libbar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/libbar-1.0.0.tar.gz
new file mode 100644
index 0000000..7c5a840
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/libbar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/libbaz-0.1.0.tar.gz b/tests/common/dependency-alternatives/t11a/libbaz-0.1.0.tar.gz
new file mode 100644
index 0000000..b8bfaec
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/libbaz-0.1.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/libbaz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/libbaz-1.0.0.tar.gz
new file mode 100644
index 0000000..9fde627
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/libbaz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/libbox-0.1.0.tar.gz b/tests/common/dependency-alternatives/t11a/libbox-0.1.0.tar.gz
new file mode 100644
index 0000000..3388a94
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/libbox-0.1.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/libbox-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/libbox-1.0.0.tar.gz
new file mode 100644
index 0000000..8a417e4
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/libbox-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/libfoo-0.1.0.tar.gz b/tests/common/dependency-alternatives/t11a/libfoo-0.1.0.tar.gz
new file mode 100644
index 0000000..a94b8fe
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/libfoo-0.1.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/libfoo-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/libfoo-1.0.0.tar.gz
new file mode 100644
index 0000000..52ba91b
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/libfoo-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/repositories.manifest b/tests/common/dependency-alternatives/t11a/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t11a/tax-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/tax-1.0.0.tar.gz
new file mode 100644
index 0000000..616cb05
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/tax-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/tex-0.1.0.tar.gz b/tests/common/dependency-alternatives/t11a/tex-0.1.0.tar.gz
new file mode 100644
index 0000000..eb7d09f
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/tex-0.1.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/tex-0.2.0.tar.gz b/tests/common/dependency-alternatives/t11a/tex-0.2.0.tar.gz
new file mode 100644
index 0000000..0b21183
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/tex-0.2.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/tex-0.3.0.tar.gz b/tests/common/dependency-alternatives/t11a/tex-0.3.0.tar.gz
new file mode 100644
index 0000000..836a032
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/tex-0.3.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/tex-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/tex-1.0.0.tar.gz
new file mode 100644
index 0000000..3c9093d
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/tex-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/tez-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/tez-1.0.0.tar.gz
new file mode 100644
index 0000000..edf378b
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/tez-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/tix-0.1.0.tar.gz b/tests/common/dependency-alternatives/t11a/tix-0.1.0.tar.gz
new file mode 100644
index 0000000..2badf78
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/tix-0.1.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/tix-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/tix-1.0.0.tar.gz
new file mode 100644
index 0000000..a1f2930
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/tix-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/tiz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/tiz-1.0.0.tar.gz
new file mode 100644
index 0000000..63c5876
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/tiz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/toz-0.1.0.tar.gz b/tests/common/dependency-alternatives/t11a/toz-0.1.0.tar.gz
new file mode 100644
index 0000000..b99803c
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/toz-0.1.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/toz-0.2.0.tar.gz b/tests/common/dependency-alternatives/t11a/toz-0.2.0.tar.gz
new file mode 100644
index 0000000..b2bd931
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/toz-0.2.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/toz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/toz-1.0.0.tar.gz
new file mode 100644
index 0000000..ccfc094
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/toz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t11a/tux-1.0.0.tar.gz b/tests/common/dependency-alternatives/t11a/tux-1.0.0.tar.gz
new file mode 100644
index 0000000..62c4e73
--- /dev/null
+++ b/tests/common/dependency-alternatives/t11a/tux-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13a/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13a/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..db3c22d
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13a/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13a/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13a/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..f86b0aa
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13a/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13a/biz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13a/biz-1.0.0.tar.gz
new file mode 100644
index 0000000..cfa8fa2
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13a/biz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13a/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13a/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..c177a1b
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13a/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13a/repositories.manifest b/tests/common/dependency-alternatives/t13a/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13a/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13b/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13b/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..5b49774
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13b/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13b/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13b/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..cb136b4
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13b/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13b/biz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13b/biz-1.0.0.tar.gz
new file mode 100644
index 0000000..27fe077
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13b/biz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13b/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13b/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..ee1dd3a
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13b/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13b/repositories.manifest b/tests/common/dependency-alternatives/t13b/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13b/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13c/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13c/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..83ad484
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13c/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13c/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13c/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..b64552e
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13c/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13c/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13c/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..5b79dc9
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13c/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13c/repositories.manifest b/tests/common/dependency-alternatives/t13c/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13c/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13d/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13d/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..5683176
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13d/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13d/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13d/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..8101c5d
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13d/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13d/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13d/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..f2965f5
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13d/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13d/libb-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13d/libb-1.0.0.tar.gz
new file mode 100644
index 0000000..0f13429
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13d/libb-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13d/repositories.manifest b/tests/common/dependency-alternatives/t13d/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13d/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13e/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13e/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..7211afb
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13e/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13e/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13e/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..e5f2880
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13e/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13e/biz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13e/biz-1.0.0.tar.gz
new file mode 100644
index 0000000..afd7db3
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13e/biz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13e/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13e/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..f3cb165
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13e/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13e/repositories.manifest b/tests/common/dependency-alternatives/t13e/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13e/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13f/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13f/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..7a255a1
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13f/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13f/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13f/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..f697c81
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13f/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13f/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13f/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..877305f
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13f/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13f/repositories.manifest b/tests/common/dependency-alternatives/t13f/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13f/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13g/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13g/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..5c8a596
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13g/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13g/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13g/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..011ffea
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13g/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13g/biz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13g/biz-1.0.0.tar.gz
new file mode 100644
index 0000000..77cb421
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13g/biz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13g/box-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13g/box-1.0.0.tar.gz
new file mode 100644
index 0000000..5217e88
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13g/box-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13g/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13g/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..2ee35ae
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13g/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13g/libb-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13g/libb-1.0.0.tar.gz
new file mode 100644
index 0000000..0f13429
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13g/libb-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13g/repositories.manifest b/tests/common/dependency-alternatives/t13g/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13g/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13h/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13h/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..7e85fca
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13h/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13h/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13h/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..6fbdf82
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13h/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13h/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13h/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..ffd380c
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13h/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13h/repositories.manifest b/tests/common/dependency-alternatives/t13h/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13h/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13i/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13i/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..6c1076d
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13i/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13i/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13i/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..b086ef4
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13i/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13i/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13i/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..4a7bd22
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13i/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13i/repositories.manifest b/tests/common/dependency-alternatives/t13i/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13i/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13j/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13j/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..8660e0f
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13j/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13j/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13j/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..7483377
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13j/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13j/biz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13j/biz-1.0.0.tar.gz
new file mode 100644
index 0000000..948c1c4
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13j/biz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13j/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13j/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..0c94586
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13j/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13j/repositories.manifest b/tests/common/dependency-alternatives/t13j/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13j/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13k/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13k/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..51de0c5
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13k/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13k/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13k/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..a8c62ba
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13k/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13k/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13k/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..c4a4b32
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13k/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13k/repositories.manifest b/tests/common/dependency-alternatives/t13k/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13k/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13l/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13l/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..d114c5c
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13l/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13l/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13l/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..e884965
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13l/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13l/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13l/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..3590340
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13l/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13l/libb-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13l/libb-1.0.0.tar.gz
new file mode 100644
index 0000000..409f438
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13l/libb-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13l/repositories.manifest b/tests/common/dependency-alternatives/t13l/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13l/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13m/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13m/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..7a2bc53
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13m/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13m/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13m/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..c5028f7
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13m/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13m/bix-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13m/bix-1.0.0.tar.gz
new file mode 100644
index 0000000..9d45acc
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13m/bix-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13m/biz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13m/biz-1.0.0.tar.gz
new file mode 100644
index 0000000..d12852b
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13m/biz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13m/box-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13m/box-1.0.0.tar.gz
new file mode 100644
index 0000000..316458d
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13m/box-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13m/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13m/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..3857354
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13m/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13m/repositories.manifest b/tests/common/dependency-alternatives/t13m/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13m/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13n/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13n/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..d3d3a24
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13n/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13n/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13n/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..fd96b61
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13n/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13n/libb-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13n/libb-1.0.0.tar.gz
new file mode 100644
index 0000000..409f438
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13n/libb-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13n/repositories.manifest b/tests/common/dependency-alternatives/t13n/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13n/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/dependency-alternatives/t13o/bar-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13o/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..d6ed94c
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13o/bar-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13o/baz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13o/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..7c1f3b7
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13o/baz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13o/bix-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13o/bix-1.0.0.tar.gz
new file mode 100644
index 0000000..cdbba8d
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13o/bix-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13o/biz-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13o/biz-1.0.0.tar.gz
new file mode 100644
index 0000000..a7908c1
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13o/biz-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13o/liba-1.0.0.tar.gz b/tests/common/dependency-alternatives/t13o/liba-1.0.0.tar.gz
new file mode 100644
index 0000000..d9dcd50
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13o/liba-1.0.0.tar.gz
diff --git a/tests/common/dependency-alternatives/t13o/repositories.manifest b/tests/common/dependency-alternatives/t13o/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/dependency-alternatives/t13o/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/satisfy/t12a/libbar-0.1.0.tar.gz b/tests/common/satisfy/t12a/libbar-0.1.0.tar.gz
new file mode 100644
index 0000000..10c7f29
--- /dev/null
+++ b/tests/common/satisfy/t12a/libbar-0.1.0.tar.gz
diff --git a/tests/common/satisfy/t12a/libbaz-1.0.0.tar.gz b/tests/common/satisfy/t12a/libbaz-1.0.0.tar.gz
new file mode 100644
index 0000000..1d498b8
--- /dev/null
+++ b/tests/common/satisfy/t12a/libbaz-1.0.0.tar.gz
diff --git a/tests/common/satisfy/t12a/repositories.manifest b/tests/common/satisfy/t12a/repositories.manifest
new file mode 100644
index 0000000..5b70556
--- /dev/null
+++ b/tests/common/satisfy/t12a/repositories.manifest
@@ -0,0 +1 @@
+: 1
diff --git a/tests/common/satisfy/t12b/bar-1.0.0.tar.gz b/tests/common/satisfy/t12b/bar-1.0.0.tar.gz
new file mode 100644
index 0000000..8999e1a
--- /dev/null
+++ b/tests/common/satisfy/t12b/bar-1.0.0.tar.gz
diff --git a/tests/common/satisfy/t12b/baz-0.1.0.tar.gz b/tests/common/satisfy/t12b/baz-0.1.0.tar.gz
new file mode 100644
index 0000000..2676c52
--- /dev/null
+++ b/tests/common/satisfy/t12b/baz-0.1.0.tar.gz
diff --git a/tests/common/satisfy/t12b/baz-1.0.0.tar.gz b/tests/common/satisfy/t12b/baz-1.0.0.tar.gz
new file mode 100644
index 0000000..1aec461
--- /dev/null
+++ b/tests/common/satisfy/t12b/baz-1.0.0.tar.gz
diff --git a/tests/common/satisfy/t12b/foo-0.1.0.tar.gz b/tests/common/satisfy/t12b/foo-0.1.0.tar.gz
new file mode 100644
index 0000000..a282f20
--- /dev/null
+++ b/tests/common/satisfy/t12b/foo-0.1.0.tar.gz
diff --git a/tests/common/satisfy/t12b/foo-1.0.0.tar.gz b/tests/common/satisfy/t12b/foo-1.0.0.tar.gz
new file mode 100644
index 0000000..4c66d3d
--- /dev/null
+++ b/tests/common/satisfy/t12b/foo-1.0.0.tar.gz
diff --git a/tests/common/satisfy/t12b/libbar-1.0.0.tar.gz b/tests/common/satisfy/t12b/libbar-1.0.0.tar.gz
new file mode 100644
index 0000000..c0fe278
--- /dev/null
+++ b/tests/common/satisfy/t12b/libbar-1.0.0.tar.gz
diff --git a/tests/common/satisfy/t12b/libbaz-0.1.0.tar.gz b/tests/common/satisfy/t12b/libbaz-0.1.0.tar.gz
new file mode 100644
index 0000000..73c0edb
--- /dev/null
+++ b/tests/common/satisfy/t12b/libbaz-0.1.0.tar.gz
diff --git a/tests/common/satisfy/t12b/repositories.manifest b/tests/common/satisfy/t12b/repositories.manifest
new file mode 100644
index 0000000..6387e01
--- /dev/null
+++ b/tests/common/satisfy/t12b/repositories.manifest
@@ -0,0 +1,4 @@
+: 1
+:
+location: ../t12a
+role: prerequisite
diff --git a/tests/pkg-build.testscript b/tests/pkg-build.testscript
index b5954f2..86a63f1 100644
--- a/tests/pkg-build.testscript
+++ b/tests/pkg-build.testscript
@@ -171,6 +171,211 @@
 # |   |-- libfoo-tests-1.0.0.tar.gz
 # |   `-- repositories.manifest
 # |
+# |-- t11a
+# |   |-- libfoo-0.1.0.tar.gz
+# |   |-- libfoo-1.0.0.tar.gz
+# |   |-- libbar-0.1.0.tar.gz
+# |   |-- libbar-1.0.0.tar.gz
+# |   |-- libbaz-0.1.0.tar.gz
+# |   |-- libbaz-1.0.0.tar.gz
+# |   |-- libbox-0.1.0.tar.gz
+# |   |-- libbox-1.0.0.tar.gz
+# |   |-- foo-1.0.0.tar.gz      -> libfoo {require {config.libfoo.extras=true}}
+# |   |-- fox-1.0.0.tar.gz      -> libfoo {require {config.libfoo.extras=true}}
+# |   |-- fux-1.0.0.tar.gz      -> libfoo
+# |   |-- fix-1.0.0.tar.gz      -> foo {require {config.foo.extras=true}}
+# |   |-- fex-1.0.0.tar.gz      -> foo, libfoo {require {config.libfoo.extras=true}}
+# |   |-- bar-0.1.0.tar.gz      -> libbar == 0.1.0 {require {config.libbar.extras=true}}
+# |   |-- bar-1.0.0.tar.gz      -> libbar {require {config.libbar.extras=true}}
+# |   |-- baz-0.1.0.tar.gz      -> {libbar libfoo} == 0.1.0 {require {config.libbar.extras=true config.libfoo.extras=true}}
+# |   |-- baz-1.0.0.tar.gz      -> {libbar libfoo} {require {config.libbar.extras=true config.libfoo.extras=true}}
+# |   |-- bac-1.0.0.tar.gz      -> libbar {require {config.libbar.extras=true}},
+# |   |                            libbaz {require {config.libbaz.extras=true}},
+# |   |                            libfoo {require {config.libfoo.extras=true}}
+# |   |-- bat-1.0.0.tar.gz      -> libbaz {require {config.libbaz.extras=true}}
+# |   |-- bas-1.0.0.tar.gz      -> libbar {require {config.libbar.extras=true}},
+# |   |                            bus {require {config.bus.extras=true}}
+# |   |-- bus-1.0.0.tar.gz      -> libaz {require {config.libbox.extras=true}},
+# |   |                            foo {require {config.foo.extras=true}}
+# |   |-- box-0.1.0.tar.gz      -> libbox {require {config.libbox.extras=true}}
+# |   |-- box-1.0.0.tar.gz      -> {libbar libfoo} {require {config.libbar.extras=true config.libfoo.extras=true}} |
+# |   |                            libbox
+# |   |-- bax-1.0.0.tar.gz      -> libfoo {require {config.libfoo.extras=true}},
+# |   |                            {libbox libbar} {require {config.libbox.extras=true config.libbar.extras=true}}
+# |   |-- bux-1.0.0.tar.gz      -> libbar {require {config.libbar.extras=true}}
+# |   |-- bix-1.0.0.tar.gz      -> {libbar bar} {require {config.libbar.extras=true config.bar.extras=true}},
+# |   |                            bux
+# |   |-- bex-1.0.0.tar.gz      -> libbar
+# |   |-- boo-1.0.0.tar.gz      -> libbar | libfoo {require {config.libfoo.extras=true}} | libbox
+# |   |-- biz-1.0.0.tar.gz      -> boo {require {config.boo.extras=true}}
+# |   |-- buz-1.0.0.tar.gz      -> bux {require {config.bux.extras=true}}
+# |   |-- buc-1.0.0.tar.gz      -> libfoo {require {config.libfoo.extras=true}},
+# |   |                            bux {require {config.bux.extras=true}}
+# |   |-- tax-1.0.0.tar.gz      -> libbar {require {config.libbar.extras=true}},
+# |   |                            libfoo
+# |   |-- tex-0.1.0.tar.gz      -> libfoo {require {config.libfoo.extras=true}}
+# |   |-- tex-0.2.0.tar.gz      -> libbar,
+# |   |                            libfoo {require {config.libfoo.extras=true}}
+# |   |-- tex-0.3.0.tar.gz      -> libbar {require {config.libbar.extras=true}},
+# |   |                            libfoo {require {config.libfoo.extras=true}}
+# |   |-- tex-1.0.0.tar.gz      -> libbar {require {config.libbar.extras=true}},
+# |   |                            libfoo {require {config.libfoo.extras=true}}
+# |   |-- tix-0.1.0.tar.gz
+# |   |-- tix-1.0.0.tar.gz      -> libbar {require {config.libbar.extras=true}},
+# |   |                            tex {require {config.tex.extras=true}}
+# |   |-- tiz-1.0.0.tar.gz      -> tex {require {config.tex.extras=true}},
+# |   |                            libbar {require {config.libbar.extras=true}}
+# |   |-- toz-0.1.0.tar.gz
+# |   |-- toz-0.2.0.tar.gz      -> libfoo {require {config.libfoo.extras=true}},
+# |   |                            libbar {require {config.libbar.extras=true}}
+# |   |-- toz-1.0.0.tar.gz      -> libbaz {require {config.libbaz.extras=true}},
+# |   |                            libfoo {require {config.libfoo.extras=true}},
+# |   |                            libbar {require {config.libbar.extras=true}}
+# |   |-- tez-1.0.0.tar.gz      -> libbox {require {config.libbox.extras=true}},
+# |   |                            toz == 0.1.0 {require {config.toz.extras=true}},
+# |   |                            libbar {require {config.libbar.extras=true}}
+# |   |-- tux-1.0.0.tar.gz      -> libbox {require {config.libbox.extras=true}},
+# |   |                            tix == 0.1.0
+# |   |-- dex-1.0.0.tar.gz      -> bar {require {config.bar.extras=true}},
+# |   |                            libfoo {require {config.libfoo.extras=true}}
+# |   |-- dix-1.0.0.tar.gz      -> libbar {require {config.libbar.extras=true}},
+# |   |                            libbox {require {config.libbox.extras=true}},
+# |   |                            dox {require {config.dox.extras=true}}
+# |   |-- diz-1.0.0.tar.gz      -> dox {require {config.dox.extras=true}},
+# |   |                            libbox {require {config.libbox.extras=true}},
+# |   |                            libbar {require {config.libbar.extras=true}}
+# |   |-- dox-1.0.0.tar.gz      -> dex {require {config.dex.extras=true}}
+# |   `-- repositories.manifest
+# |
+# |-- t12a
+# |   |-- libbaz-1.0.0.tar.gz
+# |   |-- libbar-0.1.0.tar.gz   -> libbaz
+# |   `-- repositories.manifest
+# |
+# |-- t12b                      -> t12b (prerequisite repository)
+# |   |-- libbaz-0.1.0.tar.gz
+# |   |-- libbar-1.0.0.tar.gz   -> libbaz == 0.1.0
+# |   |-- foo-0.1.0.tar.gz
+# |   |-- foo-1.0.0.tar.gz      -> libbar
+# |   |-- bar-1.0.0.tar.gz      -> libbar == 0.1.0
+# |   |-- baz-0.1.0.tar.gz      -> libbaz
+# |   |-- baz-1.0.0.tar.gz      -> libbaz == 1.0.0
+# |   `-- repositories.manifest
+# |
+# |-- t13a
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   |-- baz-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   |-- biz-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   `-- repositories.manifest
+# |
+# |-- t13b
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   |-- baz-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   |-- biz-1.0.0.tar.gz      -> liba {require {...}}
+# |   `-- repositories.manifest
+# |
+# |-- t13c
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {prefer {...} accept (...) reflect (...)}
+# |   |-- baz-1.0.0.tar.gz      -> liba {require {...}}
+# |   `-- repositories.manifest
+# |
+# |-- t13d
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- libb-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {prefer {...} accept (...) reflect (...)},
+# |   |                            libb ? (...)
+# |   |-- baz-1.0.0.tar.gz      -> bar, liba {require {...}}
+# |   `-- repositories.manifest
+# |
+# |-- t13e
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   |-- baz-1.0.0.tar.gz      -> liba {prefer {...} accept (...)},
+# |   |                            bar ? (...),
+# |   |                            biz
+# |   |-- biz-1.0.0.tar.gz      -> liba {require {...}}
+# |   `-- repositories.manifest
+# |
+# |-- t13f
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   |-- baz-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   `-- repositories.manifest
+# |
+# |-- t13g
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- libb-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {prefer {...} accept (...) reflect (...)},
+# |   |                            libb {prefer {...} accept (...) reflect (...)}
+# |   |-- baz-1.0.0.tar.gz      -> liba {prefer {...} accept (...) reflect (...)},
+# |   |                            libb ? (...)
+# |   |-- biz-1.0.0.tar.gz      -> liba {prefer {...} accept (...) reflect (...)},
+# |   |                            libb {prefer {...} accept (...) reflect (...)}
+# |   |-- box-1.0.0.tar.gz      -> liba {prefer {...} accept (...) reflect (...)},
+# |   |                            libb {prefer {...} accept (...) reflect (...)}
+# |   `-- repositories.manifest
+# |
+# |-- t13h
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   |-- baz-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   `-- repositories.manifest
+# |
+# |-- t13i
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {require {...} reflect (...)}
+# |   `-- repositories.manifest
+# |
+# |-- t13j
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   |-- baz-1.0.0.tar.gz      -> liba {require {...}}
+# |   |-- biz-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   `-- repositories.manifest
+# |
+# |-- t13k
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   |-- baz-1.0.0.tar.gz      -> liba {prefer {...} accept (...)}
+# |   `-- repositories.manifest
+# |
+# |-- t13l
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- libb-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {require {...}},
+# |   |                            libb ? (...)
+# |   |-- baz-1.0.0.tar.gz      -> liba {prefer {...} accept (...)},
+# |   |                            libb ? (...)
+# |   `-- repositories.manifest
+# |
+# |-- t13m
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {require {...}}
+# |   |-- baz-1.0.0.tar.gz      -> liba {require {...}},
+# |   |                            bar  { enable (...) reflect {...}}
+# |   |-- biz-1.0.0.tar.gz      -> liba {require {...}}
+# |   |-- bix-1.0.0.tar.gz      -> liba {require {...}}
+# |   |-- box-1.0.0.tar.gz      -> liba {require {...}}
+# |   `-- repositories.manifest
+# |
+# |-- t13n
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- libb-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {reflect {...}},
+# |   |                            libb {reflect {...}}
+# |   `-- repositories.manifest
+# |
+# |-- t13o
+# |   |-- liba-0.1.0.tar.gz
+# |   |-- bar-1.0.0.tar.gz      -> liba {reflect {...}}
+# |   |-- baz-1.0.0.tar.gz      -> bar  {require {...}}
+# |   |-- biz-1.0.0.tar.gz      -> bar  {prefer {...} accept (...)}
+# |   |-- bix-1.0.0.tar.gz      -> bar  {prefer {...} accept (...)}
+# |   `-- repositories.manifest
+# |
 # `-- git
 #     |-- libbar.git            -> style-basic.git (prerequisite repository)
 #     |-- libbaz.git
@@ -183,25 +388,43 @@ posix = ($cxx.target.class != 'windows')
 +if! $remote
   rep_create += 2>!
 
-  cp -r $src/t0a $out/t0a && $rep_create $out/t0a &$out/t0a/packages.manifest
-  cp -r $src/t0b $out/t0b && $rep_create $out/t0b &$out/t0b/packages.manifest
-  cp -r $src/t0c $out/t0c && $rep_create $out/t0c &$out/t0c/packages.manifest
-  cp -r $src/t0d $out/t0d && $rep_create $out/t0d &$out/t0d/packages.manifest
-  cp -r $src/t1  $out/t1  && $rep_create $out/t1  &$out/t1/packages.manifest
-  cp -r $src/t2  $out/t2  && $rep_create $out/t2  &$out/t2/packages.manifest
-  cp -r $src/t3  $out/t3  && $rep_create $out/t3  &$out/t3/packages.manifest
-  cp -r $src/t4a $out/t4a && $rep_create $out/t4a &$out/t4a/packages.manifest
-  cp -r $src/t4b $out/t4b && $rep_create $out/t4b &$out/t4b/packages.manifest
-  cp -r $src/t4c $out/t4c && $rep_create $out/t4c &$out/t4c/packages.manifest
-  cp -r $src/t4d $out/t4d && $rep_create $out/t4d &$out/t4d/packages.manifest
-  cp -r $src/t4e $out/t4e && $rep_create $out/t4e &$out/t4e/packages.manifest
-  cp -r $src/t5  $out/t5  && $rep_create $out/t5  &$out/t5/packages.manifest
-  cp -r $src/t6  $out/t6  && $rep_create $out/t6  &$out/t6/packages.manifest
-  cp -r $src/t7a $out/t7a && $rep_create $out/t7a &$out/t7a/packages.manifest
-  cp -r $src/t7b $out/t7b && $rep_create $out/t7b &$out/t7b/packages.manifest
-  cp -r $src/t8a $out/t8a && $rep_create $out/t8a &$out/t8a/packages.manifest
-  cp -r $src/t9  $out/t9  && $rep_create $out/t9  &$out/t9/packages.manifest
-  cp -r $src/t10 $out/t10 && $rep_create $out/t10 &$out/t10/packages.manifest
+  cp -r $src/t0a  $out/t0a  && $rep_create $out/t0a  &$out/t0a/packages.manifest
+  cp -r $src/t0b  $out/t0b  && $rep_create $out/t0b  &$out/t0b/packages.manifest
+  cp -r $src/t0c  $out/t0c  && $rep_create $out/t0c  &$out/t0c/packages.manifest
+  cp -r $src/t0d  $out/t0d  && $rep_create $out/t0d  &$out/t0d/packages.manifest
+  cp -r $src/t1   $out/t1   && $rep_create $out/t1   &$out/t1/packages.manifest
+  cp -r $src/t2   $out/t2   && $rep_create $out/t2   &$out/t2/packages.manifest
+  cp -r $src/t3   $out/t3   && $rep_create $out/t3   &$out/t3/packages.manifest
+  cp -r $src/t4a  $out/t4a  && $rep_create $out/t4a  &$out/t4a/packages.manifest
+  cp -r $src/t4b  $out/t4b  && $rep_create $out/t4b  &$out/t4b/packages.manifest
+  cp -r $src/t4c  $out/t4c  && $rep_create $out/t4c  &$out/t4c/packages.manifest
+  cp -r $src/t4d  $out/t4d  && $rep_create $out/t4d  &$out/t4d/packages.manifest
+  cp -r $src/t4e  $out/t4e  && $rep_create $out/t4e  &$out/t4e/packages.manifest
+  cp -r $src/t5   $out/t5   && $rep_create $out/t5   &$out/t5/packages.manifest
+  cp -r $src/t6   $out/t6   && $rep_create $out/t6   &$out/t6/packages.manifest
+  cp -r $src/t7a  $out/t7a  && $rep_create $out/t7a  &$out/t7a/packages.manifest
+  cp -r $src/t7b  $out/t7b  && $rep_create $out/t7b  &$out/t7b/packages.manifest
+  cp -r $src/t8a  $out/t8a  && $rep_create $out/t8a  &$out/t8a/packages.manifest
+  cp -r $src/t9   $out/t9   && $rep_create $out/t9   &$out/t9/packages.manifest
+  cp -r $src/t10  $out/t10  && $rep_create $out/t10  &$out/t10/packages.manifest
+  cp -r $src/t11a $out/t11a && $rep_create $out/t11a &$out/t11a/packages.manifest
+  cp -r $src/t12a $out/t12a && $rep_create $out/t12a &$out/t12a/packages.manifest
+  cp -r $src/t12b $out/t12b && $rep_create $out/t12b &$out/t12b/packages.manifest
+  cp -r $src/t13a $out/t13a && $rep_create $out/t13a &$out/t13a/packages.manifest
+  cp -r $src/t13b $out/t13b && $rep_create $out/t13b &$out/t13b/packages.manifest
+  cp -r $src/t13c $out/t13c && $rep_create $out/t13c &$out/t13c/packages.manifest
+  cp -r $src/t13d $out/t13d && $rep_create $out/t13d &$out/t13d/packages.manifest
+  cp -r $src/t13e $out/t13e && $rep_create $out/t13e &$out/t13e/packages.manifest
+  cp -r $src/t13f $out/t13f && $rep_create $out/t13f &$out/t13f/packages.manifest
+  cp -r $src/t13g $out/t13g && $rep_create $out/t13g &$out/t13g/packages.manifest
+  cp -r $src/t13h $out/t13h && $rep_create $out/t13h &$out/t13h/packages.manifest
+  cp -r $src/t13i $out/t13i && $rep_create $out/t13i &$out/t13i/packages.manifest
+  cp -r $src/t13j $out/t13j && $rep_create $out/t13j &$out/t13j/packages.manifest
+  cp -r $src/t13k $out/t13k && $rep_create $out/t13k &$out/t13k/packages.manifest
+  cp -r $src/t13l $out/t13l && $rep_create $out/t13l &$out/t13l/packages.manifest
+  cp -r $src/t13m $out/t13m && $rep_create $out/t13m &$out/t13m/packages.manifest
+  cp -r $src/t13n $out/t13n && $rep_create $out/t13n &$out/t13n/packages.manifest
+  cp -r $src/t13o $out/t13o && $rep_create $out/t13o &$out/t13o/packages.manifest
 
   # Create git repositories.
   #
@@ -2712,6 +2935,30 @@ test.options += --no-progress
         $pkg_drop libbar libbaz
       }
 
+      : sys-to-src-unhold-same-ver
+      :
+      : Same as above but the version does not change.
+      :
+      {
+        $clone_cfg;
+
+        $* 'sys:libbaz/0.1.0' 2>>EOE;
+          configured sys:libbaz/0.1.0
+          EOE
+
+        $* ?libbaz libbar/0.0.3 2>>EOE;
+          purged libbaz/0.1.0
+          fetched libbaz/0.1.0
+          unpacked libbaz/0.1.0
+          fetched libbar/0.0.3
+          unpacked libbar/0.0.3
+          configured libbaz/0.1.0
+          configured libbar/0.0.3
+          EOE
+
+        $pkg_drop libbar libbaz
+      }
+
       : sys-to-src
       :
       : As above but keep held.
@@ -3382,7 +3629,7 @@ test.options += --no-progress
     {
       +$clone_cfg
 
-      test.arguments += --yes
+      test.arguments += --yes --plan 'build plan:'
 
       : ambiguity
       :
@@ -3409,6 +3656,10 @@ test.options += --no-progress
           $clone_cfg;
 
           $* fox ?libbaz 2>>~%EOE%;
+            build plan:
+              new libbaz/1.1.0
+              new fox/1.0.0
+                config.fox.backend=libbaz (set by fox)
             fetched libbaz/1.1.0
             unpacked libbaz/1.1.0
             fetched fox/1.0.0
@@ -3430,6 +3681,10 @@ test.options += --no-progress
           $clone_cfg;
 
           $* fox libbaz 2>>~%EOE%;
+            build plan:
+              new libbaz/1.1.0
+              new fox/1.0.0
+                config.fox.backend=libbaz (set by fox)
             fetched libbaz/1.1.0
             unpacked libbaz/1.1.0
             fetched fox/1.0.0
@@ -3454,6 +3709,9 @@ test.options += --no-progress
           $* libbaz 2>!;
 
           $* fox 2>>~%EOE%;
+            build plan:
+              new fox/1.0.0
+                config.fox.backend=libbaz (set by fox)
             fetched fox/1.0.0
             unpacked fox/1.0.0
             configured fox/1.0.0
@@ -3473,6 +3731,10 @@ test.options += --no-progress
           $pkg_fetch libbaz/1.0.0;
 
           $* fox 2>>~%EOE%;
+            build plan:
+              update libbaz/1.0.0 (required by fox)
+              new fox/1.0.0
+                config.fox.backend=libbaz (set by fox)
             unpacked libbaz/1.0.0
             fetched fox/1.0.0
             unpacked fox/1.0.0
@@ -3497,6 +3759,12 @@ test.options += --no-progress
           $clone_cfg;
 
           $* fox foo 2>>~%EOE%;
+            build plan:
+              new libbaz/1.1.0 (required by foo)
+              new libbar/1.0.0 (required by foo, fox)
+              new fox/1.0.0
+                config.fox.backend=libbar (set by fox)
+              new foo/1.0.0
             fetched libbaz/1.1.0
             unpacked libbaz/1.1.0
             fetched libbar/1.0.0
@@ -3525,6 +3793,13 @@ test.options += --no-progress
           $clone_cfg;
 
           $* baz fox bar 2>>~%EOE%;
+            build plan:
+              new libbaz/1.1.0 (required by baz)
+              new baz/1.0.0
+              new libbar/1.0.0 (required by bar, fox)
+              new fox/1.0.0
+                config.fox.backend=libbar (set by fox)
+              new bar/1.0.0
             fetched libbaz/1.1.0
             unpacked libbaz/1.1.0
             fetched baz/1.0.0
@@ -3566,6 +3841,10 @@ test.options += --no-progress
         $clone_cfg;
 
         $* fox ?libbaz/1.0.0 2>>~%EOE%;
+          build plan:
+            new libbaz/1.0.0
+            new fox/1.0.0
+              config.fox.backend=libbaz (set by fox)
           fetched libbaz/1.0.0
           unpacked libbaz/1.0.0
           fetched fox/1.0.0
@@ -3579,6 +3858,9 @@ test.options += --no-progress
           EOE
 
         $* ?libbaz 2>>~%EOE%;
+          build plan:
+            upgrade libbaz/1.1.0
+            reconfigure fox (dependent of libbaz)
           disfigured fox/1.0.0
           disfigured libbaz/1.0.0
           fetched libbaz/1.1.0
@@ -3621,6 +3903,10 @@ test.options += --no-progress
             $* box libbox 2>!;
 
             $* box +{ config.box.extras=true } ?libbiz 2>>~%EOE%;
+              build plan:
+                reconfigure/update box/1.0.0
+                  config.box.extras=true (user configuration)
+                  config.box.backend=libbox (set by box)
               disfigured box/1.0.0
               configured box/1.0.0
               %info: .+box-1.0.0.+ is up to date%
@@ -3628,6 +3914,11 @@ test.options += --no-progress
               EOE
 
             $* box +{ config.box.extras=false } libbiz 2>>~%EOE%;
+              build plan:
+                reconfigure/update box/1.0.0
+                  config.box.extras=false (user configuration)
+                  config.box.backend=libbox (set by box)
+                new libbiz/1.0.0
               disfigured box/1.0.0
               fetched libbiz/1.0.0
               unpacked libbiz/1.0.0
@@ -3667,6 +3958,12 @@ test.options += --no-progress
             $* box libbox 2>!;
 
             $* box +{ config.box.extras=true } ?libbox/0.1.0 2>>~%EOE%;
+              build plan:
+                new libbiz/1.0.0 (required by box)
+                drop libbox/1.0.0 (unused)
+                reconfigure/update box/1.0.0
+                  config.box.extras=true (user configuration)
+                  config.box.backend=libbiz (set by box)
               disfigured box/1.0.0
               disfigured libbox/1.0.0
               fetched libbiz/1.0.0
@@ -3702,6 +3999,12 @@ test.options += --no-progress
             $* box libbox 2>!;
 
             $* box +{ config.box.extras=true } libbox/0.1.0 2>>~%EOE%;
+              build plan:
+                new libbiz/1.0.0 (required by box)
+                downgrade libbox/0.1.0
+                reconfigure/update box/1.0.0
+                  config.box.extras=true (user configuration)
+                  config.box.backend=libbiz (set by box)
               disfigured box/1.0.0
               disfigured libbox/1.0.0
               fetched libbiz/1.0.0
@@ -3739,6 +4042,11 @@ test.options += --no-progress
           $clone_cfg;
 
           $* box ?libbiz/0.1.0 2>>~%EOE%;
+            build plan:
+              new libbox/1.0.0 (required by box)
+              new libbaz/1.1.0 (required by box)
+              new box/1.0.0
+                config.box.backend=libbox (set by box)
             fetched libbox/1.0.0
             unpacked libbox/1.0.0
             fetched libbaz/1.1.0
@@ -3767,6 +4075,10 @@ test.options += --no-progress
           # libbox as a prerequisite of box.
           #
           $* libbiz ?libbaz/1.0.0 2>>~%EOE%;
+            build plan:
+              new libbiz/1.0.0
+              downgrade libbaz/1.0.0
+              reconfigure box (dependent of libbaz)
             disfigured box/1.0.0
             disfigured libbaz/1.1.0
             fetched libbiz/1.0.0
@@ -3799,6 +4111,9 @@ test.options += --no-progress
           # Make sure the decision is hold for downgraded dependency either.
           #
           $* ?libbox/0.1.1 2>>~%EOE%;
+            build plan:
+              downgrade libbox/0.1.1
+              reconfigure box (dependent of libbox)
             disfigured box/1.0.0
             disfigured libbox/1.0.0
             fetched libbox/0.1.1
@@ -4134,7 +4449,7 @@ test.options += --no-progress
           $* fax/ 2>>~%EOE% != 0;
             <depends-enable-clause>:1: error: invalid bool value: multiple names
               info: enable condition: (config.fax.libbiz = true)
-            %  .+fax.manifest:10:10: info: depends value defined here%
+            %  fax.manifest:10:10: info: in depends manifest value defined here%
             info: while satisfying fax/1.0.0#3
             EOE
 
@@ -4403,6 +4718,8351 @@ test.options += --no-progress
       }
     }
   }
+
+  : version-replacement
+  :
+  {
+    +$clone_root_cfg && $rep_add $rep/t12b && $rep_fetch
+
+    test.arguments += --yes
+
+    : not-replaced
+    :
+    {
+      $clone_cfg;
+
+      $* bar foo 2>!;
+
+      $pkg_status -r >>EOO;
+        !bar configured 1.0.0
+          libbar configured 0.1.0 available 1.0.0
+            libbaz configured 1.0.0
+        !foo configured 1.0.0
+          libbar configured 0.1.0 available 1.0.0
+            libbaz configured 1.0.0
+        EOO
+
+      $pkg_drop bar foo
+    }
+
+    : replaced-scratch
+    :
+    : Test that changing package order on the command line does not result
+    : in a sub-optimal choice of the libbaz version (0.1.0).
+    :
+    : Note that this was not the case until we implemented the builds
+    : re-collection on the package version change.
+    :
+    {
+      $clone_cfg;
+
+      $* foo bar --verbose 5 2>>~%EOE%;
+        %.*
+        trace: pkg_build: refine package collection/plan execution from scratch
+        %.*
+        trace: collect_build: add foo/1.0.0
+        trace: collect_build: add bar/1.0.0
+        trace: collect_build_prerequisites: begin foo/1.0.0
+        %.*
+        trace: collect_build: add libbar/1.0.0
+        trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent foo/1.0.0
+        trace: collect_build_prerequisites: begin libbar/1.0.0
+        %.*
+        trace: collect_build: add libbaz/0.1.0
+        trace: collect_build_prerequisites: no cfg-clause for dependency libbaz/0.1.0 of dependent libbar/1.0.0
+        trace: collect_build_prerequisites: begin libbaz/0.1.0
+        trace: collect_build_prerequisites: end libbaz/0.1.0
+        trace: collect_build_prerequisites: end libbar/1.0.0
+        trace: collect_build_prerequisites: end foo/1.0.0
+        trace: collect_build_prerequisites: begin bar/1.0.0
+        %.*
+        trace: collect_build: pick libbar/0.1.0 over libbar/1.0.0
+        trace: collect_build: libbar/1.0.0 package version needs to be replaced with libbar/0.1.0
+        trace: pkg_build: collection failed due to package version replacement, retry from scratch
+        %.*
+        trace: pkg_build: refine package collection/plan execution from scratch
+        %.*
+        trace: collect_build: add foo/1.0.0
+        trace: collect_build: add bar/1.0.0
+        trace: collect_build_prerequisites: begin foo/1.0.0
+        %.*
+        trace: collect_build: apply version replacement for libbar/1.0.0
+        trace: collect_build: replacement: libbar/0.1.0
+        trace: collect_build: add libbar/0.1.0
+        trace: collect_build_prerequisites: no cfg-clause for dependency libbar/0.1.0 of dependent foo/1.0.0
+        trace: collect_build_prerequisites: begin libbar/0.1.0
+        %.*
+        trace: collect_build: add libbaz/1.0.0
+        trace: collect_build_prerequisites: no cfg-clause for dependency libbaz/1.0.0 of dependent libbar/0.1.0
+        trace: collect_build_prerequisites: begin libbaz/1.0.0
+        trace: collect_build_prerequisites: end libbaz/1.0.0
+        trace: collect_build_prerequisites: end libbar/0.1.0
+        trace: collect_build_prerequisites: end foo/1.0.0
+        trace: collect_build_prerequisites: begin bar/1.0.0
+        %.*
+        trace: collect_build_prerequisites: no cfg-clause for dependency libbar/0.1.0 of dependent bar/1.0.0
+        trace: collect_build_prerequisites: end bar/1.0.0
+        trace: execute_plan: simulate: yes
+        %.*
+        EOE
+
+      $pkg_status -r >>EOO;
+        !foo configured 1.0.0
+          libbar configured 0.1.0 available 1.0.0
+            libbaz configured 1.0.0
+        !bar configured 1.0.0
+          libbar configured 0.1.0 available 1.0.0
+            libbaz configured 1.0.0
+        EOO
+
+      $pkg_drop foo bar
+    }
+
+    : replaced-inplace
+    :
+    : Test the version replacement optimization. Here libbaz/1.0.0 get
+    : replaced with 0.1.0 but without re-collection from scratch since it
+    : does not have any dependencies.
+    :
+    {
+      $clone_cfg && $rep_add $rep/t12a && $rep_fetch;
+
+      $* libbaz libbar  --verbose 5 2>>~%EOE%;
+        %.*
+        trace: pkg_build: refine package collection/plan execution from scratch
+        %.*
+        trace: collect_build: add libbaz/1.0.0
+        trace: collect_build: add libbar/1.0.0
+        trace: collect_build_prerequisites: begin libbaz/1.0.0
+        %.*
+        trace: collect_build_prerequisites: end libbaz/1.0.0
+        trace: collect_build_prerequisites: begin libbar/1.0.0
+        %.*
+        trace: collect_build: pick libbaz/0.1.0 over libbaz/1.0.0
+        trace: collect_build: libbaz/1.0.0 package version needs to be replaced in-place with libbaz/0.1.0
+        trace: collect_build_prerequisites: no cfg-clause for dependency libbaz/0.1.0 of dependent libbar/1.0.0
+        trace: collect_build_prerequisites: begin libbaz/0.1.0
+        trace: collect_build_prerequisites: end libbaz/0.1.0
+        trace: collect_build_prerequisites: end libbar/1.0.0
+        trace: execute_plan: simulate: yes
+        %.*
+        EOE
+
+      $pkg_status -r >>EOO;
+        !libbaz configured 0.1.0 available 1.0.0
+        !libbar configured 1.0.0
+          !libbaz configured 0.1.0 available 1.0.0
+        EOO
+
+      $pkg_drop libbaz libbar
+    }
+  }
+
+  : drop-dependent
+  :
+  {
+    +$clone_root_cfg && $rep_add $rep/t12b && $rep_fetch
+
+    test.arguments += --yes
+
+    : unhold
+    :
+    : Test that the being dropped dependent does not constrain a dependency
+    : anymore.
+    :
+    {
+      $clone_cfg;
+
+      $* libbar 2>!;
+
+      $pkg_status -r >>EOO;
+        !libbar configured 1.0.0
+          libbaz configured 0.1.0 available [1.0.0]
+        EOO
+
+      $* baz/0.1.0 ?libbar ?libbaz 2>!;
+
+      $pkg_status -r >>EOO;
+        !baz configured !0.1.0 available 1.0.0
+          libbaz configured 1.0.0
+        EOO
+
+      $pkg_drop baz
+    }
+
+    : unuse
+    :
+    : Unlike the previous test, at the time we check the constraint applied
+    : by libbar on libbaz (== 0.1.0) there is no evidence that libbar will be
+    : dropped, which will happen some later execution plan refinement
+    : iteration.
+    :
+    : @@ This scenario is not supported yet and fails with:
+    :
+    :    error: unable to upgrade package libbaz/0.1.0 to 1.0.0
+    :      info: because package libbar depends on (libbaz == 0.1.0)
+    :      info: package libbaz/1.0.0 required by baz
+    :      info: explicitly request up/downgrade of package libbar
+    :      info: or explicitly specify package libbaz version to manually satisfy these constraints
+    :
+    :    We could probably fix this postponing the constraints check in
+    :    collect_order_dependents() until the final execution plan is produced
+    :    (after all that refinement iterations). We could have an additional
+    :    iteration after all the refinements which would enable the constraint
+    :    check in collect_order_dependents().
+    :
+    if false
+    {
+      $clone_cfg;
+
+      $* foo 2>!;
+
+      $pkg_status -r >>EOO;
+        !foo configured 1.0.0
+          libbar configured 1.0.0
+            libbaz configured 0.1.0 available [1.0.0]
+        EOO
+
+      $* baz foo/0.1.0 2>|;
+
+      $pkg_status -r >>EOO;
+        EOO
+
+      $pkg_drop foo
+    }
+  }
+
+  : configuration-negotiation-order
+  :
+  {
+    +$clone_root_cfg && $rep_add $rep/t11a && $rep_fetch
+
+    test.arguments += --yes --plan 'build plan:' --verbose 5 --build-option --quiet
+
+    : initial-collection
+    :
+    {
+      +$clone_cfg
+
+      : postpone
+      :
+      {
+        $clone_cfg;
+
+        $* foo fox fux 2>>~%EOE%;
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build: add fox/1.0.0
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          trace: collect_build_prerequisites: begin fox/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent fox/1.0.0
+          trace: postponed_configurations::add: add {fox 1,1: libfoo} to {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone fox/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {foo fox | libfoo->{foo/1,1 fox/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {foo fox | libfoo->{foo/1,1 fox/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+          trace: collect_build_prerequisites: resume foo/1.0.0
+          trace: collect_build_prerequisites: end foo/1.0.0
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent fox/1.0.0
+          trace: collect_build_prerequisites: resume fox/1.0.0
+          trace: collect_build_prerequisites: end fox/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {foo fox | libfoo->{foo/1,1 fox/1,1}}!
+          trace: collect_build_postponed (1): end {foo fox | libfoo->{foo/1,1 fox/1,1}}
+          trace: collect_build_postponed (0): end
+          trace: execute_plan: simulate: yes
+          %.*
+          build plan:
+            new libfoo/1.0.0 (required by foo, fox, fux)
+              config.libfoo.extras=true (set by foo)
+            new foo/1.0.0
+            new fox/1.0.0
+            new fux/1.0.0
+          %.*
+          EOE
+
+        $pkg_status -r >>EOO;
+          !foo configured 1.0.0
+            libfoo configured 1.0.0
+          !fox configured 1.0.0
+            libfoo configured 1.0.0
+          !fux configured 1.0.0
+            libfoo configured 1.0.0
+          EOO
+
+        $pkg_drop foo fox fux
+      }
+
+      : postpone-system
+      :
+      {
+        $clone_cfg;
+
+        $* foo fox '?sys:libfoo/*' 2>>~%EOE%;
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build: add fox/1.0.0
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency sys:libfoo/* of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          trace: collect_build_prerequisites: begin fox/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency sys:libfoo/* of dependent fox/1.0.0
+          trace: postponed_configurations::add: add {fox 1,1: libfoo} to {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone fox/1.0.0
+          %.*
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {foo fox | libfoo->{foo/1,1 fox/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {foo fox | libfoo->{foo/1,1 fox/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: skip system sys:libfoo/*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+          trace: collect_build_prerequisites: resume foo/1.0.0
+          trace: collect_build_prerequisites: end foo/1.0.0
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent fox/1.0.0
+          trace: collect_build_prerequisites: resume fox/1.0.0
+          trace: collect_build_prerequisites: end fox/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {foo fox | libfoo->{foo/1,1 fox/1,1}}!
+          trace: collect_build_postponed (1): end {foo fox | libfoo->{foo/1,1 fox/1,1}}
+          trace: collect_build_postponed (0): end
+          %.*
+          trace: execute_plan: simulate: yes
+          %.*
+          build plan:
+            configure sys:libfoo/*
+              config.libfoo.extras=true (expected by foo)
+            new foo/1.0.0
+            new fox/1.0.0
+          %.*
+          EOE
+
+        $pkg_status -r >>EOO;
+          !foo configured 1.0.0
+            libfoo configured,system !* available 1.0.0 0.1.0
+          !fox configured 1.0.0
+            libfoo configured,system !* available 1.0.0 0.1.0
+          EOO
+
+        $pkg_drop foo fox
+      }
+
+      : postpone-merge
+      :
+      {
+        $clone_cfg;
+
+        $* foo bar baz 2>>~%EOE%;
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build: add bar/1.0.0
+          trace: collect_build: add baz/1.0.0
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          trace: collect_build_prerequisites: begin bar/1.0.0
+          %.*
+          trace: collect_build: add libbar/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+          trace: postponed_configurations::add: create {bar | libbar->{bar/1,1}}
+          trace: collect_build_prerequisites: postpone bar/1.0.0
+          trace: collect_build_prerequisites: begin baz/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent baz/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent baz/1.0.0
+          trace: postponed_configurations::add: add {baz 1,1: libbar libfoo} to {foo | libfoo->{foo/1,1}}
+          trace: postponed_configurations::add: merge {bar | libbar->{bar/1,1}} into {baz foo | libfoo->{baz/1,1 foo/1,1} libbar->{baz/1,1}}
+          trace: collect_build_prerequisites: postpone baz/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {bar baz foo | libfoo->{baz/1,1 foo/1,1} libbar->{bar/1,1 baz/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {bar baz foo | libfoo->{baz/1,1 foo/1,1} libbar->{bar/1,1 baz/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_prerequisites: begin libbar/1.0.0
+          trace: collect_build_prerequisites: end libbar/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bar/1.0.0
+          trace: collect_build_prerequisites: resume bar/1.0.0
+          trace: collect_build_prerequisites: end bar/1.0.0
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent baz/1.0.0
+          trace: collect_build_prerequisites: resume baz/1.0.0
+          trace: collect_build_prerequisites: end baz/1.0.0
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+          trace: collect_build_prerequisites: resume foo/1.0.0
+          trace: collect_build_prerequisites: end foo/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {bar baz foo | libfoo->{baz/1,1 foo/1,1} libbar->{bar/1,1 baz/1,1}}!
+          trace: collect_build_postponed (1): end {bar baz foo | libfoo->{baz/1,1 foo/1,1} libbar->{bar/1,1 baz/1,1}}
+          trace: collect_build_postponed (0): end
+          trace: execute_plan: simulate: yes
+          %.*
+          build plan:
+            new libfoo/1.0.0 (required by baz, foo)
+              config.libfoo.extras=true (set by baz)
+            new foo/1.0.0
+            new libbar/1.0.0 (required by bar, baz)
+              config.libbar.extras=true (set by bar)
+            new bar/1.0.0
+            new baz/1.0.0
+          %.*
+          EOE
+
+        $pkg_status -r >>EOO;
+          !foo configured 1.0.0
+            libfoo configured 1.0.0
+          !bar configured 1.0.0
+            libbar configured 1.0.0
+          !baz configured 1.0.0
+            libbar configured 1.0.0
+            libfoo configured 1.0.0
+          EOO
+
+        $pkg_drop foo bar baz
+      }
+
+      : postpone-dependency-dependent
+      :
+      {
+        $clone_cfg;
+
+        $* fex 2>>~%EOE%;
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fex/1.0.0
+          trace: collect_build_prerequisites: begin fex/1.0.0
+          %.*
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build_prerequisites: no cfg-clause for dependency foo/1.0.0 of dependent fex/1.0.0
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent fex/1.0.0
+          trace: postponed_configurations::add: add {fex 2,1: libfoo} to {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone fex/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {fex foo | libfoo->{fex/2,1 foo/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {fex foo | libfoo->{fex/2,1 foo/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent fex/1.0.0
+          trace: collect_build_prerequisites: resume fex/1.0.0
+          trace: collect_build_prerequisites: end fex/1.0.0
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+          trace: collect_build_prerequisites: resume foo/1.0.0
+          trace: collect_build_prerequisites: end foo/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {fex foo | libfoo->{fex/2,1 foo/1,1}}!
+          trace: collect_build_postponed (1): end {fex foo | libfoo->{fex/2,1 foo/1,1}}
+          trace: collect_build_postponed (0): end
+          trace: execute_plan: simulate: yes
+          %.*
+          EOE
+
+        $pkg_status -r >>EOO;
+          !fex configured 1.0.0
+            foo configured 1.0.0
+              libfoo configured 1.0.0
+            libfoo configured 1.0.0
+          EOO
+
+        $pkg_drop fex
+      }
+
+      : premature
+      :
+      {
+        $clone_cfg;
+
+        $* fux foo fox 2>>~%EOE%;
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build: add fox/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cannot cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0 (collected prematurely), throwing postpone_dependency
+          trace: pkg_build: collection failed due to prematurely collected dependency (libfoo), retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build: add fox/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          trace: collect_build_prerequisites: begin fox/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent fox/1.0.0
+          trace: postponed_configurations::add: add {fox 1,1: libfoo} to {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone fox/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {foo fox | libfoo->{foo/1,1 fox/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {foo fox | libfoo->{foo/1,1 fox/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+          trace: collect_build_prerequisites: resume foo/1.0.0
+          trace: collect_build_prerequisites: end foo/1.0.0
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent fox/1.0.0
+          trace: collect_build_prerequisites: resume fox/1.0.0
+          trace: collect_build_prerequisites: end fox/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {foo fox | libfoo->{foo/1,1 fox/1,1}}!
+          trace: collect_build_postponed (1): end {foo fox | libfoo->{foo/1,1 fox/1,1}}
+          trace: collect_build_postponed (0): end
+          trace: execute_plan: simulate: yes
+          %.*
+          EOE
+
+        $pkg_status -r >>EOO;
+          !fux configured 1.0.0
+            libfoo configured 1.0.0
+          !foo configured 1.0.0
+            libfoo configured 1.0.0
+          !fox configured 1.0.0
+            libfoo configured 1.0.0
+          EOO
+
+        $pkg_drop fux foo fox
+      }
+
+      : bogus-postponment
+      :
+      {
+        $clone_cfg;
+
+        $* fux foo fix 2>>~%EOE%;
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build: add fix/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cannot cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0 (collected prematurely), throwing postpone_dependency
+          trace: pkg_build: collection failed due to prematurely collected dependency (libfoo), retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build: add fix/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          trace: collect_build_prerequisites: begin fix/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cannot cfg-postpone dependency foo/1.0.0 of dependent fix/1.0.0 (collected prematurely), throwing postpone_dependency
+          trace: pkg_build: collection failed due to prematurely collected dependency (foo), retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build: add fix/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: pkg_build: dep-postpone user-specified foo
+          trace: collect_build_prerequisites: begin fix/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency foo/1.0.0 of dependent fix/1.0.0
+          trace: postponed_configurations::add: create {fix | foo->{fix/1,1}}
+          trace: collect_build_prerequisites: postpone fix/1.0.0
+          trace: pkg_build: erase bogus postponement libfoo
+          trace: pkg_build: bogus postponements erased, throwing
+          trace: pkg_build: collection failed due to bogus dependency collection postponement cancellation, retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build: add fix/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: pkg_build: dep-postpone user-specified foo
+          trace: collect_build_prerequisites: begin fix/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency foo/1.0.0 of dependent fix/1.0.0
+          trace: postponed_configurations::add: create {fix | foo->{fix/1,1}}
+          trace: collect_build_prerequisites: postpone fix/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cannot cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0 (collected prematurely), throwing postpone_dependency
+          trace: pkg_build: collection failed due to prematurely collected dependency (libfoo), retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build: add fix/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          trace: collect_build_prerequisites: begin fix/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cannot cfg-postpone dependency foo/1.0.0 of dependent fix/1.0.0 (collected prematurely), throwing postpone_dependency
+          trace: pkg_build: collection failed due to prematurely collected dependency (foo), retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build: add fix/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: pkg_build: dep-postpone user-specified foo
+          trace: collect_build_prerequisites: begin fix/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency foo/1.0.0 of dependent fix/1.0.0
+          trace: postponed_configurations::add: create {fix | foo->{fix/1,1}}
+          trace: collect_build_prerequisites: postpone fix/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent fix/1.0.0
+          trace: collect_build_prerequisites: resume fix/1.0.0
+          trace: collect_build_prerequisites: end fix/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {fix | foo->{fix/1,1}}!
+          trace: collect_build_postponed (2): begin {foo | libfoo->{foo/1,1}}
+          %.*
+          trace: collect_build_postponed (2): cfg-negotiate begin {foo | libfoo->{foo/1,1}}
+          %.*
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+          trace: collect_build_prerequisites: resume foo/1.0.0
+          trace: collect_build_prerequisites: end foo/1.0.0
+          trace: collect_build_postponed (2): cfg-negotiate end {foo | libfoo->{foo/1,1}}!
+          trace: collect_build_postponed (2): end {foo | libfoo->{foo/1,1}}
+          trace: collect_build_postponed (1): end {fix | foo->{fix/1,1}}
+          trace: collect_build_postponed (0): end
+          trace: execute_plan: simulate: yes
+          %.*
+          EOE
+
+        $pkg_status -r >>EOO;
+          !fux configured 1.0.0
+            libfoo configured 1.0.0
+          !foo configured 1.0.0
+            libfoo configured 1.0.0
+          !fix configured 1.0.0
+            !foo configured 1.0.0
+              libfoo configured 1.0.0
+          EOO
+
+        $pkg_drop fux foo fix
+      }
+    }
+
+    : existing
+    :
+    {
+      +$clone_cfg
+
+      : dependency
+      :
+      {
+        $clone_cfg;
+
+        $* libfoo 2>!;
+
+        $* foo 2>>~%EOE%;
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {foo | libfoo->{foo/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {foo | libfoo->{foo/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+          trace: collect_build_prerequisites: resume foo/1.0.0
+          trace: collect_build_prerequisites: end foo/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {foo | libfoo->{foo/1,1}}!
+          trace: collect_build_postponed (1): end {foo | libfoo->{foo/1,1}}
+          trace: collect_build_postponed (0): end
+          %.*
+          trace: execute_plan: simulate: yes
+          %.*
+          build plan:
+            reconfigure/update libfoo/1.0.0 (required by foo)
+              config.libfoo.extras=true (set by foo)
+            new foo/1.0.0
+          %.*
+          EOE
+
+        $pkg_status -r >>EOO;
+          !libfoo configured 1.0.0
+          !foo configured 1.0.0
+            !libfoo configured 1.0.0
+          EOO
+
+        $pkg_drop foo libfoo
+      }
+
+      : dependent-single-position
+      :
+      {
+        +$clone_cfg
+
+        : basic
+        :
+        {
+          $clone_cfg;
+
+          $* foo 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add foo/1.0.0
+            trace: collect_build_prerequisites: begin foo/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+            trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+            trace: collect_build_prerequisites: postpone foo/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {foo | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {foo | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+            trace: collect_build_prerequisites: resume foo/1.0.0
+            trace: collect_build_prerequisites: end foo/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {foo | libfoo->{foo/1,1}}!
+            trace: collect_build_postponed (1): end {foo | libfoo->{foo/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          # Downgrade the dependency.
+          #
+          $* ?libfoo/0.1.0 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: execute_plan: simulate: yes
+            %.*
+            trace: evaluate_dependency: libfoo/1.0.0: update to libfoo/0.1.0
+            %.*
+            trace: pkg_build: refine package collection/plan execution
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/0.1.0 of existing dependent foo/1.0.0
+            trace: postponed_configurations::add: create {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {foo^ | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): re-evaluate existing dependents for {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build: add foo/1.0.0
+            trace: collect_build_prerequisites: reeval foo/1.0.0
+            %.*
+            trace: collect_build: pick libfoo/0.1.0 over libfoo/1.0.0
+            trace: postponed_configurations::add: add {foo^ 1,1: libfoo} to {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_prerequisites: re-evaluating dependent foo/1.0.0 results in {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_prerequisites: re-evaluated foo/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate begin {foo^ | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/0.1.0
+            trace: collect_build_prerequisites: end libfoo/0.1.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+            trace: collect_build_prerequisites: resume foo/1.0.0
+            trace: collect_build_prerequisites: end foo/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {foo^ | libfoo->{foo/1,1}}!
+            trace: collect_build_postponed (1): end {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_postponed (0): end
+            %.*
+            trace: execute_plan: simulate: yes
+            %.*
+            build plan:
+              downgrade libfoo/0.1.0
+                config.libfoo.extras=true (set by foo)
+              reconfigure/update foo/1.0.0 (dependent of libfoo)
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !foo configured 1.0.0
+              libfoo configured !0.1.0 available 1.0.0
+            EOO
+
+          # Reconfigure the dependency and hold.
+          #
+          $* libfoo/0.1.0 +{ config.libfoo.extras=true } 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add libfoo/0.1.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/0.1.0 of existing dependent foo/1.0.0
+            trace: postponed_configurations::add: create {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {foo^ | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): re-evaluate existing dependents for {foo^ | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build: add foo/1.0.0
+            trace: collect_build_prerequisites: reeval foo/1.0.0
+            %.*
+            trace: postponed_configurations::add: add {foo^ 1,1: libfoo} to {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_prerequisites: re-evaluating dependent foo/1.0.0 results in {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_prerequisites: re-evaluated foo/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate begin {foo^ | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: skip configured libfoo/0.1.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+            trace: collect_build_prerequisites: resume foo/1.0.0
+            trace: collect_build_prerequisites: end foo/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {foo^ | libfoo->{foo/1,1}}!
+            trace: collect_build_postponed (1): end {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_postponed (0): end
+            %.*
+            trace: execute_plan: simulate: yes
+            %.*
+            build plan:
+              reconfigure/update libfoo/0.1.0
+                config.libfoo.extras=true (user configuration)
+              reconfigure/update foo/1.0.0 (dependent of libfoo)
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !libfoo configured !0.1.0 available 1.0.0
+            !foo configured 1.0.0
+              !libfoo configured !0.1.0 available 1.0.0
+            EOO
+
+          # Upgrade the dependency and unhold existing dependent.
+          #
+          $* libfoo ?foo 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of existing dependent foo/1.0.0
+            trace: postponed_configurations::add: create {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {foo^ | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): re-evaluate existing dependents for {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_prerequisites: reeval foo/1.0.0
+            %.*
+            trace: collect_build: pick libfoo/1.0.0 over libfoo/0.1.0
+            trace: postponed_configurations::add: add {foo^ 1,1: libfoo} to {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_prerequisites: re-evaluating dependent foo/1.0.0 results in {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_prerequisites: re-evaluated foo/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate begin {foo^ | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+            trace: collect_build_prerequisites: resume foo/1.0.0
+            trace: collect_build_prerequisites: end foo/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {foo^ | libfoo->{foo/1,1}}!
+            trace: collect_build_postponed (1): end {foo^ | libfoo->{foo/1,1}}
+            trace: collect_build_postponed (0): end
+            %.*
+            trace: execute_plan: simulate: yes
+            %.*
+            trace: evaluate_dependency: foo/1.0.0: unused
+            %.*
+            trace: pkg_build: refine package collection/plan execution
+            %.*
+            trace: collect_drop: foo/1.0.0 package version needs to be replaced with drop
+            trace: pkg_build: collection failed due to package version replacement, retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: skip expected to be dropped existing dependent foo of dependency libfoo
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_drop: overwrite foo
+            %.*
+            trace: execute_plan: simulate: yes
+            %.*
+            build plan:
+              upgrade libfoo/1.0.0
+              drop foo/1.0.0 (unused)
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !libfoo configured 1.0.0
+            EOO
+
+          $pkg_drop libfoo
+        }
+
+        : postpone-existing
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  fix/1.0.0: depends: foo(c)
+          #  foo/1.0.0: depends: libfoo(c)
+          #
+          #  fix/0.1.0: depends: foo == 0.1.0
+          #  foo/0.1.0: depends: libfoo(c)
+          #
+          $* fix 2>!;
+
+          $* libfoo/0.1.0 fix/0.1.0 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add libfoo/0.1.0
+            trace: collect_build: add fix/0.1.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/0.1.0 of existing dependent foo/1.0.0
+            trace: postponed_configurations::add: create {foo^ | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_prerequisites: begin fix/0.1.0
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add libfoo/0.1.0
+            trace: collect_build: add fix/0.1.0
+            %.*
+            trace: collect_build_prerequisites: skip expected to be built existing dependent foo of dependency libfoo
+            trace: collect_build_prerequisites: begin libfoo/0.1.0
+            trace: collect_build_prerequisites: end libfoo/0.1.0
+            %.*
+            trace: collect_build_prerequisites: begin fix/0.1.0
+            %.*
+            trace: collect_build: apply version replacement for foo/0.1.0
+            trace: collect_build: replacement: foo/0.1.0
+            trace: collect_build: add foo/0.1.0
+            info: package fix dependency on (foo == 0.1.0) is forcing downgrade of foo/1.0.0 to 0.1.0
+            trace: collect_build_prerequisites: no cfg-clause for dependency foo/0.1.0 of dependent fix/0.1.0
+            %.*
+            trace: collect_build_prerequisites: skip being built existing dependent fix of dependency foo
+            trace: collect_build_prerequisites: begin foo/0.1.0
+            %.*
+            trace: collect_build: pick libfoo/0.1.0 over libfoo/1.0.0
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency libfoo/0.1.0 of dependent foo/0.1.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (libfoo), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add libfoo/0.1.0
+            trace: collect_build: add fix/0.1.0
+            trace: pkg_build: dep-postpone user-specified libfoo
+            %.*
+            trace: collect_build_prerequisites: begin fix/0.1.0
+            %.*
+            trace: collect_build: apply version replacement for foo/0.1.0
+            trace: collect_build: replacement: foo/0.1.0
+            trace: collect_build: add foo/0.1.0
+            info: package fix dependency on (foo == 0.1.0) is forcing downgrade of foo/1.0.0 to 0.1.0
+            trace: collect_build_prerequisites: no cfg-clause for dependency foo/0.1.0 of dependent fix/0.1.0
+            %.*
+            trace: collect_build_prerequisites: skip being built existing dependent fix of dependency foo
+            trace: collect_build_prerequisites: begin foo/0.1.0
+            %.*
+            trace: collect_build: pick libfoo/0.1.0 over libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/0.1.0 of dependent foo/0.1.0
+            trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+            trace: collect_build_prerequisites: postpone foo/0.1.0
+            trace: collect_build_prerequisites: end fix/0.1.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {foo | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): skip being built existing dependent foo of dependency libfoo
+            trace: collect_build_postponed (1): cfg-negotiate begin {foo | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/0.1.0
+            trace: collect_build_prerequisites: end libfoo/0.1.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/0.1.0
+            trace: collect_build_prerequisites: resume foo/0.1.0
+            trace: collect_build_prerequisites: end foo/0.1.0
+            trace: collect_build_postponed (1): cfg-negotiate end {foo | libfoo->{foo/1,1}}!
+            trace: collect_build_postponed (1): end {foo | libfoo->{foo/1,1}}
+            trace: collect_build_postponed (0): end
+            %.*
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !libfoo configured !0.1.0 available 1.0.0
+            !fix configured !0.1.0 available 1.0.0
+              foo configured 0.1.0 available 1.0.0
+                !libfoo configured !0.1.0 available 1.0.0
+            EOO
+
+          $pkg_drop fix libfoo --drop-dependent
+        }
+      }
+
+      : dependent-multiple-positions
+      :
+      {
+        +$clone_cfg
+
+        : non-negotiated
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  tex: depends: libbar(c)
+          #       depends: libfoo(c)
+          #
+          $* tex 2>!;
+
+          $* libfoo/0.1.0 libbar/0.1.0 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add libfoo/0.1.0
+            trace: collect_build: add libbar/0.1.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/0.1.0 of existing dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex^ | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/0.1.0 of existing dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex^ | libbar->{tex/1,1}}
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tex^ | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (1): re-evaluate existing dependents for {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (1): cannot re-evaluate dependent tex to dependency index 2 due to earlier dependency index 1 in {tex^ | libbar->{tex/1,1}}, skipping {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (0): postpone cfg-negotiation of {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (1): begin {tex^ | libbar->{tex/1,1}}
+            %.*
+            trace: collect_build_postponed (1): re-evaluate existing dependents for {tex^ | libbar->{tex/1,1}}
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build_prerequisites: reeval tex/1.0.0
+            %.*
+            trace: collect_build: pick libbar/0.1.0 over libbar/1.0.0
+            trace: postponed_configurations::add: add {tex^ 1,1: libbar} to {tex^ | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: re-evaluating dependent tex/1.0.0 results in {tex^ | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: re-evaluated tex/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate begin {tex^ | libbar->{tex/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/0.1.0
+            trace: collect_build_prerequisites: end libbar/0.1.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            %.*
+            trace: collect_build: pick libfoo/0.1.0 over libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/0.1.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: add {tex 2,1: libfoo} to {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tex^ | libbar->{tex/1,1}}!
+            trace: collect_build_postponed (2): begin {tex^ | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (2): skip being built existing dependent tex of dependency libfoo
+            trace: collect_build_postponed (2): cfg-negotiate begin {tex^ | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/0.1.0
+            trace: collect_build_prerequisites: end libfoo/0.1.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            trace: collect_build_prerequisites: end tex/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {tex^ | libfoo->{tex/2,1}}!
+            trace: collect_build_postponed (2): end {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (1): end {tex^ | libbar->{tex/1,1}}
+            trace: collect_build_postponed (0): end
+            %.*
+            trace: execute_plan: simulate: yes
+            %.*
+            build plan:
+              downgrade libfoo/0.1.0
+                config.libfoo.extras=true (set by tex)
+              downgrade libbar/0.1.0
+                config.libbar.extras=true (set by tex)
+              reconfigure/update tex/1.0.0 (dependent of libbar)
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !libbar configured !0.1.0 available 1.0.0
+            !libfoo configured !0.1.0 available 1.0.0
+            !tex configured 1.0.0
+              !libbar configured !0.1.0 available 1.0.0
+              !libfoo configured !0.1.0 available 1.0.0
+            EOO
+
+          $pkg_drop tex libfoo libbar
+        }
+
+        : negotiated
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  tex: depends: libbar(c)
+          #       depends: libfoo(c)
+          #
+          #  bar: depends: libbar == 0.1.0 (c)
+          #
+          $* tex 2>!;
+
+          $* libfoo/0.1.0 bar/0.1.0 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add libfoo/0.1.0
+            trace: collect_build: add bar/0.1.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/0.1.0 of existing dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: begin bar/0.1.0
+            %.*
+            trace: collect_build: add libbar/0.1.0
+            info: package bar dependency on (libbar == 0.1.0) is forcing downgrade of libbar/1.0.0 to 0.1.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/0.1.0 of dependent bar/0.1.0
+            trace: postponed_configurations::add: create {bar | libbar->{bar/1,1}}
+            trace: collect_build_prerequisites: postpone bar/0.1.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tex^ | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (1): re-evaluate existing dependents for {tex^ | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build_prerequisites: reeval tex/1.0.0
+            %.*
+            trace: collect_build: pick libbar/0.1.0 over libbar/1.0.0
+            %.*
+            trace: collect_build: pick libfoo/0.1.0 over libfoo/1.0.0
+            trace: postponed_configurations::add: add {tex^ 2,1: libfoo} to {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: re-evaluating dependent tex/1.0.0 results in {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: re-evaluated tex/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate begin {tex^ | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/0.1.0
+            trace: collect_build_prerequisites: end libfoo/0.1.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            trace: collect_build_prerequisites: end tex/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tex^ | libfoo->{tex/2,1}}!
+            trace: collect_build_postponed (2): begin {bar | libbar->{bar/1,1}}
+            %.*
+            trace: collect_build_postponed (2): re-evaluate existing dependents for {bar | libbar->{bar/1,1}}
+            trace: collect_build_postponed (2): cannot re-evaluate dependent tex to dependency index 1 due to greater dependency index 2 in {tex^ | libfoo->{tex/2,1}}!, throwing postpone_position
+            trace: pkg_build: collection failed due to earlier dependency position, retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add libfoo/0.1.0
+            trace: collect_build: add bar/0.1.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/0.1.0 of existing dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: begin bar/0.1.0
+            %.*
+            trace: collect_build: add libbar/0.1.0
+            info: package bar dependency on (libbar == 0.1.0) is forcing downgrade of libbar/1.0.0 to 0.1.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/0.1.0 of dependent bar/0.1.0
+            trace: postponed_configurations::add: create {bar | libbar->{bar/1,1}}
+            trace: collect_build_prerequisites: postpone bar/0.1.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tex^ | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (1): re-evaluate existing dependents for {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (1): pos-postpone existing dependent tex re-evaluation to dependency index 2 due to recorded index 1, skipping {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (0): postpone cfg-negotiation of {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (1): begin {bar | libbar->{bar/1,1}}
+            %.*
+            trace: collect_build_postponed (1): re-evaluate existing dependents for {bar | libbar->{bar/1,1}}
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build_prerequisites: reeval tex/1.0.0
+            %.*
+            trace: collect_build: pick libbar/0.1.0 over libbar/1.0.0
+            trace: postponed_configurations::add: add {tex^ 1,1: libbar} to {bar | libbar->{bar/1,1}}
+            trace: collect_build_prerequisites: re-evaluating dependent tex/1.0.0 results in {bar tex^ | libbar->{bar/1,1 tex/1,1}}
+            trace: collect_build_prerequisites: re-evaluated tex/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate begin {bar tex^ | libbar->{bar/1,1 tex/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/0.1.0
+            trace: collect_build_prerequisites: end libbar/0.1.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bar/0.1.0
+            trace: collect_build_prerequisites: resume bar/0.1.0
+            trace: collect_build_prerequisites: end bar/0.1.0
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            %.*
+            trace: collect_build: pick libfoo/0.1.0 over libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/0.1.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: add {tex 2,1: libfoo} to {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {bar tex^ | libbar->{bar/1,1 tex/1,1}}!
+            trace: collect_build_postponed (2): begin {tex^ | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (2): skip being built existing dependent tex of dependency libfoo
+            trace: collect_build_postponed (2): cfg-negotiate begin {tex^ | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/0.1.0
+            trace: collect_build_prerequisites: end libfoo/0.1.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            trace: collect_build_prerequisites: end tex/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {tex^ | libfoo->{tex/2,1}}!
+            trace: collect_build_postponed (2): end {tex^ | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (1): end {bar | libbar->{bar/1,1}}
+            trace: collect_build_postponed (0): end
+            %.*
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !libfoo configured !0.1.0 available 1.0.0
+            !tex configured 1.0.0
+              libbar configured 0.1.0 available 1.0.0
+              !libfoo configured !0.1.0 available 1.0.0
+            !bar configured !0.1.0 available 1.0.0
+              libbar configured 0.1.0 available 1.0.0
+            EOO
+
+          $pkg_drop tex libfoo bar
+        }
+
+        : up-negotiate
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  tex: depends: libbar(c)
+          #       depends: libfoo(c)
+          #
+          #  baz: depends: {libbar libfoo} == 0.1.0 (c)
+          #
+          $* tex 2>!;
+
+          $* baz/0.1.0 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add baz/0.1.0
+            trace: collect_build_prerequisites: begin baz/0.1.0
+            %.*
+            trace: collect_build: add libbar/0.1.0
+            info: package baz dependency on (libbar == 0.1.0) is forcing downgrade of libbar/1.0.0 to 0.1.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/0.1.0 of dependent baz/0.1.0
+            trace: collect_build: add libfoo/0.1.0
+            info: package baz dependency on (libfoo == 0.1.0) is forcing downgrade of libfoo/1.0.0 to 0.1.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/0.1.0 of dependent baz/0.1.0
+            trace: postponed_configurations::add: create {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: postpone baz/0.1.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            %.*
+            trace: collect_build_postponed (1): re-evaluate existing dependents for {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build_prerequisites: reeval tex/1.0.0
+            %.*
+            trace: collect_build: pick libbar/0.1.0 over libbar/1.0.0
+            trace: postponed_configurations::add: add {tex^ 1,1: libbar} to {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: re-evaluating dependent tex/1.0.0 results in {baz tex^ | libbar->{baz/1,1 tex/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: re-evaluated tex/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate begin {baz tex^ | libbar->{baz/1,1 tex/1,1} libfoo->{baz/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/0.1.0
+            trace: collect_build_prerequisites: end libbar/0.1.0
+            trace: collect_build_prerequisites: begin libfoo/0.1.0
+            trace: collect_build_prerequisites: end libfoo/0.1.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent baz/0.1.0
+            trace: collect_build_prerequisites: resume baz/0.1.0
+            trace: collect_build_prerequisites: end baz/0.1.0
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            %.*
+            trace: collect_build: pick libfoo/0.1.0 over libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/0.1.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: add {tex 2,1: libfoo} to {baz tex^ | libbar->{baz/1,1 tex/1,1} libfoo->{baz/1,1}}?
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tex/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libfoo/0.1.0 of dependent tex/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end tex/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {baz tex^ | libbar->{baz/1,1 tex/1,1} libfoo->{baz/1,1 tex/2,1}}!
+            trace: collect_build_postponed (1): end {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_postponed (0): end
+            %.*
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !tex configured 1.0.0
+              libbar configured 0.1.0 available 1.0.0
+              libfoo configured 0.1.0 available 1.0.0
+            !baz configured !0.1.0 available 1.0.0
+              libbar configured 0.1.0 available 1.0.0
+              libfoo configured 0.1.0 available 1.0.0
+            EOO
+
+          $pkg_drop tex baz
+        }
+
+        : replace-re-evaluation
+        :
+        {
+          +$clone_cfg
+
+          : initial-collection
+          :
+          {
+            $clone_cfg;
+
+            #  Dependencies:
+            #
+            #  bax: depends: libfoo(c)
+            #       depends: {libbox libbar} (c)
+            #
+            #  baz: depends: {libbar libfoo} (c)
+            #
+            $* bax baz 2>!;
+
+            $* libbox/0.1.0 2>>~%EOE%;
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add libbox/0.1.0
+              %.*
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/0.1.0 of existing dependent bax/1.0.0
+              trace: postponed_configurations::add: create {bax^ | libbox->{bax/2,1}}
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {bax^ | libbox->{bax/2,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {bax^ | libbox->{bax/2,1}}
+              %.*
+              trace: collect_build: add bax/1.0.0
+              trace: collect_build_prerequisites: reeval bax/1.0.0
+              %.*
+              trace: collect_build: add libfoo/1.0.0
+              %.*
+              trace: collect_build: pick libbox/0.1.0 over libbox/1.0.0
+              trace: collect_build: add libbar/1.0.0
+              trace: postponed_configurations::add: add {bax^ 2,1: libbox libbar} to {bax^ | libbox->{bax/2,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ | libbox->{bax/2,1} libbar->{bax/2,1}}
+              trace: collect_build_prerequisites: re-evaluated bax/1.0.0
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent bax of dependency libbar
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {bax^ | libbox->{bax/2,1} libbar->{bax/2,1}}
+              %.*
+              trace: collect_build: add baz/1.0.0
+              trace: collect_build_prerequisites: reeval baz/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {baz^ 1,1: libbar libfoo} to {bax^ | libbox->{bax/2,1} libbar->{bax/2,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent baz/1.0.0 results in {bax^ baz^ | libbox->{bax/2,1} libbar->{bax/2,1 baz/1,1} libfoo->{baz/1,1}}
+              trace: collect_build_prerequisites: re-evaluated baz/1.0.0
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent baz of dependency libfoo
+              trace: collect_build_postponed (1): cannot re-evaluate dependent bax to dependency index 1 since it is already re-evaluated to greater index 2 in {bax^ baz^ | libbox->{bax/2,1} libbar->{bax/2,1 baz/1,1} libfoo->{baz/1,1}}, throwing postpone_position
+              trace: pkg_build: collection failed due to earlier dependency position, retry from scratch
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add libbox/0.1.0
+              %.*
+              trace: collect_build_prerequisites: replace dependency at index 2 of existing dependent bax/1.0.0 with dependency libfoo/1.0.0 at index 1
+              trace: collect_build: add libfoo/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of existing dependent bax/1.0.0
+              trace: postponed_configurations::add: create {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {bax^ | libfoo->{bax/1,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build: add bax/1.0.0
+              trace: collect_build_prerequisites: reeval bax/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluated bax/1.0.0
+              trace: collect_build: add baz/1.0.0
+              trace: collect_build_prerequisites: reeval baz/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              trace: postponed_configurations::add: add {baz^ 1,1: libbar libfoo} to {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent baz/1.0.0 results in {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}
+              trace: collect_build_prerequisites: re-evaluated baz/1.0.0
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent bax of dependency libbar
+              trace: collect_build_postponed (1): skip being built existing dependent baz of dependency libbar
+              trace: collect_build_postponed (1): cfg-negotiate begin {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_prerequisites: skip configured libbar/1.0.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bax/1.0.0
+              trace: collect_build_prerequisites: resume bax/1.0.0
+              %.*
+              trace: collect_build: pick libbox/0.1.0 over libbox/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/0.1.0 of dependent bax/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0
+              trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}?
+              %.*
+              trace: collect_build_prerequisites: cfg-postponing dependent bax/1.0.0 involves (being) negotiated configurations and results in {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{bax/2,1 baz/1,1} libbox->{bax/2,1}}?, throwing retry_configuration
+              trace: collect_build_postponed (0): cfg-negotiation of {bax^ | libfoo->{bax/1,1}} failed due to dependent bax, refining configuration
+              trace: collect_build_postponed (1): begin {bax^ | libfoo->{bax/1,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build: add bax/1.0.0
+              trace: collect_build_prerequisites: reeval bax/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluated bax/1.0.0
+              trace: collect_build: add baz/1.0.0
+              trace: collect_build_prerequisites: reeval baz/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              trace: postponed_configurations::add: add {baz^ 1,1: libbar libfoo} to {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent baz/1.0.0 results in {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}
+              trace: collect_build_prerequisites: re-evaluated baz/1.0.0
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent bax of dependency libbar
+              trace: collect_build_postponed (1): skip being built existing dependent baz of dependency libbar
+              trace: collect_build_postponed (1): cfg-negotiate begin {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_prerequisites: skip configured libbar/1.0.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bax/1.0.0
+              trace: collect_build_prerequisites: resume bax/1.0.0
+              %.*
+              trace: collect_build: pick libbox/0.1.0 over libbox/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/0.1.0 of dependent bax/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0
+              trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}?
+              trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bax/1.0.0 is negotiated
+              trace: collect_build_prerequisites: collecting cfg-postponed dependency libbox/0.1.0 of dependent bax/1.0.0
+              trace: collect_build_prerequisites: begin libbox/0.1.0
+              trace: collect_build_prerequisites: end libbox/0.1.0
+              trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bax/1.0.0 is already (being) recursively collected, skipping
+              trace: collect_build_prerequisites: end bax/1.0.0
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent baz/1.0.0
+              trace: collect_build_prerequisites: resume baz/1.0.0
+              trace: collect_build_prerequisites: end baz/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate end {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{bax/2,1 baz/1,1} libbox->{bax/2,1}}!
+              trace: collect_build_postponed (1): end {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_postponed (0): end
+              %.*
+              trace: execute_plan: simulate: yes
+              %.*
+              EOE
+
+            $pkg_status -r >>EOO;
+              !libbox configured !0.1.0 available 1.0.0
+              !bax configured 1.0.0
+                libbar configured 1.0.0
+                !libbox configured !0.1.0 available 1.0.0
+                libfoo configured 1.0.0
+              !baz configured 1.0.0
+                libbar configured 1.0.0
+                libfoo configured 1.0.0
+              EOO
+
+            $pkg_drop bax baz libbox
+          }
+
+          : collect-postponed
+          :
+          {
+            $clone_cfg;
+
+            #  Dependencies:
+            #
+            #  bax: depends: libfoo(c)
+            #       depends: {libbox libbar} (c)
+            #
+            #  baz: depends: {libbar libfoo} (c)
+            #
+            #  box: depends: libbox == 0.1.0 (c)
+            #
+            $* bax baz 2>!;
+
+            $* box/0.1.0 2>>~%EOE%;
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add box/0.1.0
+              trace: collect_build_prerequisites: begin box/0.1.0
+              %.*
+              trace: collect_build: add libbox/0.1.0
+              info: package box dependency on (libbox == 0.1.0) is forcing downgrade of libbox/1.0.0 to 0.1.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/0.1.0 of dependent box/0.1.0
+              trace: postponed_configurations::add: create {box | libbox->{box/1,1}}
+              trace: collect_build_prerequisites: postpone box/0.1.0
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {box | libbox->{box/1,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {box | libbox->{box/1,1}}
+              %.*
+              trace: collect_build: add bax/1.0.0
+              trace: collect_build_prerequisites: reeval bax/1.0.0
+              %.*
+              trace: collect_build: add libfoo/1.0.0
+              %.*
+              trace: collect_build: pick libbox/0.1.0 over libbox/1.0.0
+              trace: collect_build: add libbar/1.0.0
+              trace: postponed_configurations::add: add {bax^ 2,1: libbox libbar} to {box | libbox->{box/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ box | libbox->{bax/2,1 box/1,1} libbar->{bax/2,1}}
+              trace: collect_build_prerequisites: re-evaluated bax/1.0.0
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent bax of dependency libbar
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {bax^ box | libbox->{bax/2,1 box/1,1} libbar->{bax/2,1}}
+              %.*
+              trace: collect_build: add baz/1.0.0
+              trace: collect_build_prerequisites: reeval baz/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {baz^ 1,1: libbar libfoo} to {bax^ box | libbox->{bax/2,1 box/1,1} libbar->{bax/2,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent baz/1.0.0 results in {bax^ baz^ box | libbox->{bax/2,1 box/1,1} libbar->{bax/2,1 baz/1,1} libfoo->{baz/1,1}}
+              trace: collect_build_prerequisites: re-evaluated baz/1.0.0
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent baz of dependency libfoo
+              trace: collect_build_postponed (1): cannot re-evaluate dependent bax to dependency index 1 since it is already re-evaluated to greater index 2 in {bax^ baz^ box | libbox->{bax/2,1 box/1,1} libbar->{bax/2,1 baz/1,1} libfoo->{baz/1,1}}, throwing postpone_position
+              trace: pkg_build: collection failed due to earlier dependency position, retry from scratch
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add box/0.1.0
+              trace: collect_build_prerequisites: begin box/0.1.0
+              %.*
+              trace: collect_build: add libbox/0.1.0
+              info: package box dependency on (libbox == 0.1.0) is forcing downgrade of libbox/1.0.0 to 0.1.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/0.1.0 of dependent box/0.1.0
+              trace: postponed_configurations::add: create {box | libbox->{box/1,1}}
+              trace: collect_build_prerequisites: postpone box/0.1.0
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {box | libbox->{box/1,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {box | libbox->{box/1,1}}
+              trace: collect_build_postponed (1): pos-postpone existing dependent bax re-evaluation to dependency index 2 due to recorded index 1, skipping {box | libbox->{box/1,1}}
+              trace: collect_build_postponed (0): replace dependency at index 2 of existing dependent bax/1.0.0 with dependency libfoo/1.0.0 at index 1
+              trace: collect_build: add libfoo/1.0.0
+              trace: postponed_configurations::add: create {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_postponed (0): postpone cfg-negotiation of {box | libbox->{box/1,1}}
+              trace: collect_build_postponed (1): begin {bax^ | libfoo->{bax/1,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build: add bax/1.0.0
+              trace: collect_build_prerequisites: reeval bax/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluated bax/1.0.0
+              trace: collect_build: add baz/1.0.0
+              trace: collect_build_prerequisites: reeval baz/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              trace: postponed_configurations::add: add {baz^ 1,1: libbar libfoo} to {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent baz/1.0.0 results in {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}
+              trace: collect_build_prerequisites: re-evaluated baz/1.0.0
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent bax of dependency libbar
+              trace: collect_build_postponed (1): skip being built existing dependent baz of dependency libbar
+              trace: collect_build_postponed (1): cfg-negotiate begin {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_prerequisites: skip configured libbar/1.0.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bax/1.0.0
+              trace: collect_build_prerequisites: resume bax/1.0.0
+              %.*
+              trace: collect_build: pick libbox/0.1.0 over libbox/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/0.1.0 of dependent bax/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0
+              trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}?
+              trace: postponed_configurations::add: merge {box | libbox->{box/1,1}} into {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{bax/2,1 baz/1,1} libbox->{bax/2,1}}?
+              trace: collect_build_prerequisites: cfg-postponing dependent bax/1.0.0 merges non-negotiated and/or being negotiated configurations in and results in {bax^ baz^ box | libfoo->{bax/1,1 baz/1,1} libbar->{bax/2,1 baz/1,1} libbox->{bax/2,1 box/1,1}}?, throwing merge_configuration
+              trace: collect_build_postponed (0): cfg-negotiation of {bax^ | libfoo->{bax/1,1}} failed due to non-negotiated clusters, force-merging based on shadow cluster {bax^ baz^ box | libfoo->{bax/1,1 baz/1,1} libbar->{bax/2,1 baz/1,1} libbox->{bax/2,1 box/1,1}}?
+              trace: collect_build_postponed (0): force-merge {box | libbox->{box/1,1}} into {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_postponed (1): begin {bax^ box | libfoo->{bax/1,1} libbox->{box/1,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {bax^ box | libfoo->{bax/1,1} libbox->{box/1,1}}
+              trace: collect_build: add bax/1.0.0
+              trace: collect_build_prerequisites: reeval bax/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {bax^ box | libfoo->{bax/1,1} libbox->{box/1,1}} (shadow cluster-based)
+              trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ box | libfoo->{bax/1,1} libbox->{box/1,1}}
+              trace: collect_build_prerequisites: re-evaluated bax/1.0.0
+              trace: collect_build: add baz/1.0.0
+              trace: collect_build_prerequisites: reeval baz/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              trace: postponed_configurations::add: add {baz^ 1,1: libbar libfoo} to {bax^ box | libfoo->{bax/1,1} libbox->{box/1,1}} (shadow cluster-based)
+              trace: collect_build_prerequisites: re-evaluating dependent baz/1.0.0 results in {bax^ baz^ box | libfoo->{bax/1,1 baz/1,1} libbox->{box/1,1} libbar->{baz/1,1}}
+              trace: collect_build_prerequisites: re-evaluated baz/1.0.0
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent bax of dependency libbar
+              trace: collect_build_postponed (1): skip being built existing dependent baz of dependency libbar
+              trace: collect_build_postponed (1): cfg-negotiate begin {bax^ baz^ box | libfoo->{bax/1,1 baz/1,1} libbox->{box/1,1} libbar->{baz/1,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_prerequisites: begin libbox/0.1.0
+              trace: collect_build_prerequisites: end libbox/0.1.0
+              trace: collect_build_prerequisites: skip configured libbar/1.0.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bax/1.0.0
+              trace: collect_build_prerequisites: resume bax/1.0.0
+              %.*
+              trace: collect_build: pick libbox/0.1.0 over libbox/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/0.1.0 of dependent bax/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0
+              trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {bax^ baz^ box | libfoo->{bax/1,1 baz/1,1} libbox->{box/1,1} libbar->{baz/1,1}}? (shadow cluster-based)
+              trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bax/1.0.0 is shadow-negotiated
+              trace: collect_build_prerequisites: dependency libbox/0.1.0 of dependent bax/1.0.0 is already (being) recursively collected, skipping
+              trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bax/1.0.0 is already (being) recursively collected, skipping
+              trace: collect_build_prerequisites: end bax/1.0.0
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent baz/1.0.0
+              trace: collect_build_prerequisites: resume baz/1.0.0
+              trace: collect_build_prerequisites: end baz/1.0.0
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent box/0.1.0
+              trace: collect_build_prerequisites: resume box/0.1.0
+              trace: collect_build_prerequisites: end box/0.1.0
+              trace: collect_build_postponed (1): cfg-negotiate end {bax^ baz^ box | libfoo->{bax/1,1 baz/1,1} libbox->{bax/2,1 box/1,1} libbar->{bax/2,1 baz/1,1}}!
+              trace: collect_build_postponed (1): end {bax^ box | libfoo->{bax/1,1} libbox->{box/1,1}}
+              trace: collect_build_postponed (0): end
+              %.*
+              trace: execute_plan: simulate: yes
+              %.*
+              EOE
+
+            $pkg_status -r >>EOO;
+              !bax configured 1.0.0
+                libbar configured 1.0.0
+                libbox configured 0.1.0 available 1.0.0
+                libfoo configured 1.0.0
+              !baz configured 1.0.0
+                libbar configured 1.0.0
+                libfoo configured 1.0.0
+              !box configured !0.1.0 available 1.0.0
+                libbox configured 0.1.0 available 1.0.0
+              EOO
+
+            $pkg_drop bax baz box
+          }
+
+          : bogus-harmless
+          :
+          {
+            $clone_cfg;
+
+            #  Dependencies:
+            #
+            #  bax: depends: libfoo(c)
+            #       depends: {libbox libbar} (c)
+            #
+            #  baz: depends: {libbar libfoo} (c)
+            #
+            $* bax baz 2>!;
+
+            $* libbox/0.1.0 ?baz 2>>~%EOE%;
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add libbox/0.1.0
+              %.*
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/0.1.0 of existing dependent bax/1.0.0
+              trace: postponed_configurations::add: create {bax^ | libbox->{bax/2,1}}
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {bax^ | libbox->{bax/2,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {bax^ | libbox->{bax/2,1}}
+              %.*
+              trace: collect_build: add bax/1.0.0
+              trace: collect_build_prerequisites: reeval bax/1.0.0
+              %.*
+              trace: collect_build: add libfoo/1.0.0
+              %.*
+              trace: collect_build: pick libbox/0.1.0 over libbox/1.0.0
+              trace: collect_build: add libbar/1.0.0
+              trace: postponed_configurations::add: add {bax^ 2,1: libbox libbar} to {bax^ | libbox->{bax/2,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ | libbox->{bax/2,1} libbar->{bax/2,1}}
+              trace: collect_build_prerequisites: re-evaluated bax/1.0.0
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent bax of dependency libbar
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {bax^ | libbox->{bax/2,1} libbar->{bax/2,1}}
+              trace: collect_build_prerequisites: reeval baz/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {baz^ 1,1: libbar libfoo} to {bax^ | libbox->{bax/2,1} libbar->{bax/2,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent baz/1.0.0 results in {bax^ baz^ | libbox->{bax/2,1} libbar->{bax/2,1 baz/1,1} libfoo->{baz/1,1}}
+              trace: collect_build_prerequisites: re-evaluated baz/1.0.0
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent baz of dependency libfoo
+              trace: collect_build_postponed (1): cannot re-evaluate dependent bax to dependency index 1 since it is already re-evaluated to greater index 2 in {bax^ baz^ | libbox->{bax/2,1} libbar->{bax/2,1 baz/1,1} libfoo->{baz/1,1}}, throwing postpone_position
+              trace: pkg_build: collection failed due to earlier dependency position, retry from scratch
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add libbox/0.1.0
+              %.*
+              trace: collect_build_prerequisites: replace dependency at index 2 of existing dependent bax/1.0.0 with dependency libfoo/1.0.0 at index 1
+              trace: collect_build: add libfoo/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of existing dependent bax/1.0.0
+              trace: postponed_configurations::add: create {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {bax^ | libfoo->{bax/1,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build: add bax/1.0.0
+              trace: collect_build_prerequisites: reeval bax/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluated bax/1.0.0
+              trace: collect_build_prerequisites: reeval baz/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              trace: postponed_configurations::add: add {baz^ 1,1: libbar libfoo} to {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent baz/1.0.0 results in {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}
+              trace: collect_build_prerequisites: re-evaluated baz/1.0.0
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent bax of dependency libbar
+              trace: collect_build_postponed (1): skip being built existing dependent baz of dependency libbar
+              trace: collect_build_postponed (1): cfg-negotiate begin {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_prerequisites: skip configured libbar/1.0.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bax/1.0.0
+              trace: collect_build_prerequisites: resume bax/1.0.0
+              %.*
+              trace: collect_build: pick libbox/0.1.0 over libbox/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/0.1.0 of dependent bax/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0
+              trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}?
+              %.*
+              trace: collect_build_prerequisites: cfg-postponing dependent bax/1.0.0 involves (being) negotiated configurations and results in {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{bax/2,1 baz/1,1} libbox->{bax/2,1}}?, throwing retry_configuration
+              trace: collect_build_postponed (0): cfg-negotiation of {bax^ | libfoo->{bax/1,1}} failed due to dependent bax, refining configuration
+              trace: collect_build_postponed (1): begin {bax^ | libfoo->{bax/1,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build: add bax/1.0.0
+              trace: collect_build_prerequisites: reeval bax/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluated bax/1.0.0
+              trace: collect_build_prerequisites: reeval baz/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              trace: postponed_configurations::add: add {baz^ 1,1: libbar libfoo} to {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent baz/1.0.0 results in {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}
+              trace: collect_build_prerequisites: re-evaluated baz/1.0.0
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent bax of dependency libbar
+              trace: collect_build_postponed (1): skip being built existing dependent baz of dependency libbar
+              trace: collect_build_postponed (1): cfg-negotiate begin {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_prerequisites: skip configured libbar/1.0.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bax/1.0.0
+              trace: collect_build_prerequisites: resume bax/1.0.0
+              %.*
+              trace: collect_build: pick libbox/0.1.0 over libbox/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/0.1.0 of dependent bax/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0
+              trace: postponed_configurations::add: add {bax 2,1: libbox libbar} to {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{baz/1,1}}?
+              trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bax/1.0.0 is negotiated
+              trace: collect_build_prerequisites: collecting cfg-postponed dependency libbox/0.1.0 of dependent bax/1.0.0
+              trace: collect_build_prerequisites: begin libbox/0.1.0
+              trace: collect_build_prerequisites: end libbox/0.1.0
+              trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bax/1.0.0 is already (being) recursively collected, skipping
+              trace: collect_build_prerequisites: end bax/1.0.0
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent baz/1.0.0
+              trace: collect_build_prerequisites: resume baz/1.0.0
+              trace: collect_build_prerequisites: end baz/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate end {bax^ baz^ | libfoo->{bax/1,1 baz/1,1} libbar->{bax/2,1 baz/1,1} libbox->{bax/2,1}}!
+              trace: collect_build_postponed (1): end {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_postponed (0): end
+              %.*
+              trace: execute_plan: simulate: yes
+              %.*
+              trace: evaluate_dependency: baz/1.0.0: unused
+              %.*
+              trace: pkg_build: refine package collection/plan execution
+              %.*
+              trace: collect_drop: baz/1.0.0 package version needs to be replaced with drop
+              trace: pkg_build: collection failed due to package version replacement, retry from scratch
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add libbox/0.1.0
+              trace: pkg_build: dep-postpone user-specified libbox
+              trace: collect_drop: overwrite baz
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (0): erase bogus postponement libbox
+              trace: collect_build_postponed (0): bogus postponements erased, throwing
+              trace: pkg_build: collection failed due to bogus dependency collection postponement cancellation, retry from scratch
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add libbox/0.1.0
+              %.*
+              trace: collect_build_prerequisites: replace dependency at index 2 of existing dependent bax/1.0.0 with dependency libfoo/1.0.0 at index 1
+              trace: collect_build: add libfoo/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of existing dependent bax/1.0.0
+              trace: postponed_configurations::add: create {bax^ | libfoo->{bax/1,1}}
+              trace: collect_drop: overwrite baz
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {bax^ | libfoo->{bax/1,1}}
+              %.*
+              trace: collect_build_postponed (1): skip being dropped existing dependent baz of dependency libfoo
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build: add bax/1.0.0
+              trace: collect_build_prerequisites: reeval bax/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {bax^ 1,1: libfoo} to {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent bax/1.0.0 results in {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_prerequisites: re-evaluated bax/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate begin {bax^ | libfoo->{bax/1,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bax/1.0.0
+              trace: collect_build_prerequisites: resume bax/1.0.0
+              %.*
+              trace: collect_build: pick libbox/0.1.0 over libbox/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/0.1.0 of dependent bax/1.0.0
+              trace: collect_build: add libbar/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bax/1.0.0
+              trace: postponed_configurations::add: create {bax | libbox->{bax/2,1} libbar->{bax/2,1}}
+              trace: collect_build_prerequisites: postpone bax/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate end {bax^ | libfoo->{bax/1,1}}!
+              trace: collect_build_postponed (2): begin {bax | libbox->{bax/2,1} libbar->{bax/2,1}}
+              %.*
+              trace: collect_build_postponed (2): skip being built existing dependent bax of dependency libbox
+              %.*
+              trace: collect_build_postponed (2): skip being built existing dependent bax of dependency libbar
+              trace: collect_build_postponed (2): skip being dropped existing dependent baz of dependency libbar
+              trace: collect_build_postponed (2): cfg-negotiate begin {bax | libbox->{bax/2,1} libbar->{bax/2,1}}
+              %.*
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin libbox/0.1.0
+              trace: collect_build_prerequisites: end libbox/0.1.0
+              trace: collect_build_prerequisites: skip configured libbar/1.0.0
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bax/1.0.0
+              trace: collect_build_prerequisites: resume bax/1.0.0
+              trace: collect_build_prerequisites: end bax/1.0.0
+              trace: collect_build_postponed (2): cfg-negotiate end {bax | libbox->{bax/2,1} libbar->{bax/2,1}}!
+              trace: collect_build_postponed (2): end {bax | libbox->{bax/2,1} libbar->{bax/2,1}}
+              trace: collect_build_postponed (1): end {bax^ | libfoo->{bax/1,1}}
+              trace: collect_build_postponed (0): end
+              %.*
+              trace: execute_plan: simulate: yes
+              %.*
+              EOE
+
+            $pkg_status -r >>EOO;
+              !libbox configured !0.1.0 available 1.0.0
+              !bax configured 1.0.0
+                libbar configured 1.0.0
+                !libbox configured !0.1.0 available 1.0.0
+                libfoo configured 1.0.0
+              EOO
+
+            $pkg_drop bax libbox
+          }
+        }
+      }
+    }
+
+    : postponed-collection
+    :
+    {
+      +$clone_cfg
+
+      : backtrace
+      :
+      {
+        $clone_cfg;
+
+        $* foo bar box 2>>~%EOE%;
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build: add bar/1.0.0
+          trace: collect_build: add box/1.0.0
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          trace: collect_build_prerequisites: begin bar/1.0.0
+          %.*
+          trace: collect_build: add libbar/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+          trace: postponed_configurations::add: create {bar | libbar->{bar/1,1}}
+          trace: collect_build_prerequisites: postpone bar/1.0.0
+          trace: collect_build_prerequisites: begin box/1.0.0
+          %.*
+          trace: collect_build_prerequisites: alt-postpone dependent box/1.0.0 since max index is reached: 0
+            info: dependency alternative: {libbar libfoo}
+          {
+            require
+            {
+              config.libbar.extras = true
+              config.libfoo.extras = true
+            }
+          }
+          trace: collect_build_prerequisites: postpone box/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {foo | libfoo->{foo/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {foo | libfoo->{foo/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+          trace: collect_build_prerequisites: resume foo/1.0.0
+          trace: collect_build_prerequisites: end foo/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {foo | libfoo->{foo/1,1}}!
+          trace: collect_build_postponed (2): begin {bar | libbar->{bar/1,1}}
+          %.*
+          trace: collect_build_postponed (2): cfg-negotiate begin {bar | libbar->{bar/1,1}}
+          %.*
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbar/1.0.0
+          trace: collect_build_prerequisites: end libbar/1.0.0
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bar/1.0.0
+          trace: collect_build_prerequisites: resume bar/1.0.0
+          trace: collect_build_prerequisites: end bar/1.0.0
+          trace: collect_build_postponed (2): cfg-negotiate end {bar | libbar->{bar/1,1}}!
+          trace: collect_build_postponed (2): index 1 collect alt-postponed box/1.0.0
+          trace: collect_build_prerequisites: resume box/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent box/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent box/1.0.0
+          trace: postponed_configurations::add: add {box 1,1: libbar libfoo} to {foo | libfoo->{foo/1,1}}!
+          trace: postponed_configurations::add: merge {bar | libbar->{bar/1,1}}! into {box foo | libfoo->{box/1,1 foo/1,1} libbar->{box/1,1}}!
+          %.*
+          trace: collect_build_prerequisites: cfg-postponing dependent box/1.0.0 involves (being) negotiated configurations and results in {bar box foo | libfoo->{box/1,1 foo/1,1} libbar->{bar/1,1 box/1,1}}!, throwing retry_configuration
+          trace: collect_build_postponed (0): cfg-negotiation of {foo | libfoo->{foo/1,1}} failed due to dependent box, refining configuration
+          trace: collect_build_postponed (1): begin {foo | libfoo->{foo/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {foo | libfoo->{foo/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+          trace: collect_build_prerequisites: resume foo/1.0.0
+          trace: collect_build_prerequisites: end foo/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {foo | libfoo->{foo/1,1}}!
+          trace: collect_build_postponed (2): begin {bar | libbar->{bar/1,1}}
+          %.*
+          trace: collect_build_postponed (2): cfg-negotiate begin {bar | libbar->{bar/1,1}}
+          %.*
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbar/1.0.0
+          trace: collect_build_prerequisites: end libbar/1.0.0
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bar/1.0.0
+          trace: collect_build_prerequisites: resume bar/1.0.0
+          trace: collect_build_prerequisites: end bar/1.0.0
+          trace: collect_build_postponed (2): cfg-negotiate end {bar | libbar->{bar/1,1}}!
+          trace: collect_build_postponed (2): index 1 collect alt-postponed box/1.0.0
+          trace: collect_build_prerequisites: resume box/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent box/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent box/1.0.0
+          trace: postponed_configurations::add: add {box 1,1: libbar libfoo} to {foo | libfoo->{foo/1,1}}!
+          trace: postponed_configurations::add: merge {bar | libbar->{bar/1,1}}! into {box foo | libfoo->{box/1,1 foo/1,1} libbar->{box/1,1}}!
+          trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent box/1.0.0 is negotiated
+          trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent box/1.0.0 is already (being) recursively collected, skipping
+          trace: collect_build_prerequisites: dependency libfoo/1.0.0 of dependent box/1.0.0 is already (being) recursively collected, skipping
+          trace: collect_build_prerequisites: end box/1.0.0
+          trace: collect_build_postponed (2): end {bar | libbar->{bar/1,1}}
+          trace: collect_build_postponed (1): end {foo | libfoo->{foo/1,1}}
+          trace: collect_build_postponed (0): end
+          trace: execute_plan: simulate: yes
+          %.*
+          EOE
+
+        $pkg_status -r >>EOO;
+          !foo configured 1.0.0
+            libfoo configured 1.0.0
+          !bar configured 1.0.0
+            libbar configured 1.0.0
+          !box configured 1.0.0
+            libbar configured 1.0.0
+            libfoo configured 1.0.0
+          EOO
+
+        $pkg_drop foo bar box
+      }
+
+      : premature
+      :
+      {
+        $clone_cfg;
+
+        $* fux fix 2>>~%EOE%;
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add fix/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: collect_build_prerequisites: begin fix/1.0.0
+          %.*
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency foo/1.0.0 of dependent fix/1.0.0
+          trace: postponed_configurations::add: create {fix | foo->{fix/1,1}}
+          trace: collect_build_prerequisites: postpone fix/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cannot cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0 (collected prematurely), throwing postpone_dependency
+          trace: pkg_build: collection failed due to prematurely collected dependency (libfoo), retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add fix/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: collect_build_prerequisites: begin fix/1.0.0
+          %.*
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency foo/1.0.0 of dependent fix/1.0.0
+          trace: postponed_configurations::add: create {fix | foo->{fix/1,1}}
+          trace: collect_build_prerequisites: postpone fix/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent fix/1.0.0
+          trace: collect_build_prerequisites: resume fix/1.0.0
+          trace: collect_build_prerequisites: end fix/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {fix | foo->{fix/1,1}}!
+          trace: collect_build_postponed (2): begin {foo | libfoo->{foo/1,1}}
+          %.*
+          trace: collect_build_postponed (2): cfg-negotiate begin {foo | libfoo->{foo/1,1}}
+          %.*
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+          trace: collect_build_prerequisites: resume foo/1.0.0
+          trace: collect_build_prerequisites: end foo/1.0.0
+          trace: collect_build_postponed (2): cfg-negotiate end {foo | libfoo->{foo/1,1}}!
+          trace: collect_build_postponed (2): end {foo | libfoo->{foo/1,1}}
+          trace: collect_build_postponed (1): end {fix | foo->{fix/1,1}}
+          trace: collect_build_postponed (0): end
+          trace: execute_plan: simulate: yes
+          %.*
+          EOE
+
+        $pkg_status -r >>EOO;
+          !fux configured 1.0.0
+            libfoo configured 1.0.0
+          !fix configured 1.0.0
+            foo configured 1.0.0
+              libfoo configured 1.0.0
+          EOO
+
+        $pkg_drop fux fix
+      }
+
+      : double-premature
+      :
+      {
+        $clone_cfg;
+
+        $* fux bex fix buz 2>>~%EOE%;
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add bex/1.0.0
+          trace: collect_build: add fix/1.0.0
+          trace: collect_build: add buz/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: collect_build_prerequisites: begin bex/1.0.0
+          %.*
+          trace: collect_build: add libbar/1.0.0
+          trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent bex/1.0.0
+          trace: collect_build_prerequisites: begin libbar/1.0.0
+          trace: collect_build_prerequisites: end libbar/1.0.0
+          trace: collect_build_prerequisites: end bex/1.0.0
+          trace: collect_build_prerequisites: begin fix/1.0.0
+          %.*
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency foo/1.0.0 of dependent fix/1.0.0
+          trace: postponed_configurations::add: create {fix | foo->{fix/1,1}}
+          trace: collect_build_prerequisites: postpone fix/1.0.0
+          trace: collect_build_prerequisites: begin buz/1.0.0
+          %.*
+          trace: collect_build: add bux/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency bux/1.0.0 of dependent buz/1.0.0
+          trace: postponed_configurations::add: create {buz | bux->{buz/1,1}}
+          trace: collect_build_prerequisites: postpone buz/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cannot cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0 (collected prematurely), throwing postpone_dependency
+          trace: pkg_build: collection failed due to prematurely collected dependency (libfoo), retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add bex/1.0.0
+          trace: collect_build: add fix/1.0.0
+          trace: collect_build: add buz/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: collect_build_prerequisites: begin bex/1.0.0
+          %.*
+          trace: collect_build: add libbar/1.0.0
+          trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent bex/1.0.0
+          trace: collect_build_prerequisites: begin libbar/1.0.0
+          trace: collect_build_prerequisites: end libbar/1.0.0
+          trace: collect_build_prerequisites: end bex/1.0.0
+          trace: collect_build_prerequisites: begin fix/1.0.0
+          %.*
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency foo/1.0.0 of dependent fix/1.0.0
+          trace: postponed_configurations::add: create {fix | foo->{fix/1,1}}
+          trace: collect_build_prerequisites: postpone fix/1.0.0
+          trace: collect_build_prerequisites: begin buz/1.0.0
+          %.*
+          trace: collect_build: add bux/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency bux/1.0.0 of dependent buz/1.0.0
+          trace: postponed_configurations::add: create {buz | bux->{buz/1,1}}
+          trace: collect_build_prerequisites: postpone buz/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent fix/1.0.0
+          trace: collect_build_prerequisites: resume fix/1.0.0
+          trace: collect_build_prerequisites: end fix/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {fix | foo->{fix/1,1}}!
+          trace: collect_build_postponed (2): begin {buz | bux->{buz/1,1}}
+          %.*
+          trace: collect_build_postponed (2): cfg-negotiate begin {buz | bux->{buz/1,1}}
+          %.*
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin bux/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cannot cfg-postpone dependency libbar/1.0.0 of dependent bux/1.0.0 (collected prematurely), throwing postpone_dependency
+          trace: pkg_build: collection failed due to prematurely collected dependency (libbar), retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add fux/1.0.0
+          trace: collect_build: add bex/1.0.0
+          trace: collect_build: add fix/1.0.0
+          trace: collect_build: add buz/1.0.0
+          trace: collect_build_prerequisites: begin fux/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent fux/1.0.0
+          trace: collect_build_prerequisites: end fux/1.0.0
+          trace: collect_build_prerequisites: begin bex/1.0.0
+          %.*
+          trace: collect_build: add libbar/1.0.0
+          trace: collect_build_prerequisites: dep-postpone dependency libbar/1.0.0 of dependent bex/1.0.0
+          trace: collect_build_prerequisites: end bex/1.0.0
+          trace: collect_build_prerequisites: begin fix/1.0.0
+          %.*
+          trace: collect_build: add foo/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency foo/1.0.0 of dependent fix/1.0.0
+          trace: postponed_configurations::add: create {fix | foo->{fix/1,1}}
+          trace: collect_build_prerequisites: postpone fix/1.0.0
+          trace: collect_build_prerequisites: begin buz/1.0.0
+          %.*
+          trace: collect_build: add bux/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency bux/1.0.0 of dependent buz/1.0.0
+          trace: postponed_configurations::add: create {buz | bux->{buz/1,1}}
+          trace: collect_build_prerequisites: postpone buz/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {fix | foo->{fix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin foo/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+          trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+          trace: collect_build_prerequisites: postpone foo/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent fix/1.0.0
+          trace: collect_build_prerequisites: resume fix/1.0.0
+          trace: collect_build_prerequisites: end fix/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {fix | foo->{fix/1,1}}!
+          trace: collect_build_postponed (2): begin {buz | bux->{buz/1,1}}
+          %.*
+          trace: collect_build_postponed (2): cfg-negotiate begin {buz | bux->{buz/1,1}}
+          %.*
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin bux/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bux/1.0.0
+          trace: postponed_configurations::add: create {bux | libbar->{bux/1,1}}
+          trace: collect_build_prerequisites: postpone bux/1.0.0
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent buz/1.0.0
+          trace: collect_build_prerequisites: resume buz/1.0.0
+          trace: collect_build_prerequisites: end buz/1.0.0
+          trace: collect_build_postponed (2): cfg-negotiate end {buz | bux->{buz/1,1}}!
+          trace: collect_build_postponed (3): begin {foo | libfoo->{foo/1,1}}
+          %.*
+          trace: collect_build_postponed (3): cfg-negotiate begin {foo | libfoo->{foo/1,1}}
+          %.*
+          trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+          trace: collect_build_prerequisites: resume foo/1.0.0
+          trace: collect_build_prerequisites: end foo/1.0.0
+          trace: collect_build_postponed (3): cfg-negotiate end {foo | libfoo->{foo/1,1}}!
+          trace: collect_build_postponed (4): begin {bux | libbar->{bux/1,1}}
+          %.*
+          trace: collect_build_postponed (4): cfg-negotiate begin {bux | libbar->{bux/1,1}}
+          %.*
+          trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbar/1.0.0
+          trace: collect_build_prerequisites: end libbar/1.0.0
+          trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent bux/1.0.0
+          trace: collect_build_prerequisites: resume bux/1.0.0
+          trace: collect_build_prerequisites: end bux/1.0.0
+          trace: collect_build_postponed (4): cfg-negotiate end {bux | libbar->{bux/1,1}}!
+          trace: collect_build_postponed (4): end {bux | libbar->{bux/1,1}}
+          trace: collect_build_postponed (3): end {foo | libfoo->{foo/1,1}}
+          trace: collect_build_postponed (2): end {buz | bux->{buz/1,1}}
+          trace: collect_build_postponed (1): end {fix | foo->{fix/1,1}}
+          trace: collect_build_postponed (0): end
+          trace: execute_plan: simulate: yes
+          %.*
+          EOE
+
+        $pkg_status -r >>EOO;
+          !fux configured 1.0.0
+            libfoo configured 1.0.0
+          !fix configured 1.0.0
+            foo configured 1.0.0
+              libfoo configured 1.0.0
+          !bex configured 1.0.0
+            libbar configured 1.0.0
+          !buz configured 1.0.0
+            bux configured 1.0.0
+              libbar configured 1.0.0
+          EOO
+
+        $pkg_drop fux bex fix buz
+      }
+
+      : up-negotiate-dependency
+      :
+      {
+        $clone_cfg;
+
+        #  Dependencies:
+        #
+        #  bar: depends: libbar(c)
+        #
+        #  bux: depends: libbar(c)
+        #
+        #  bix: depends: {libbar bar} (c)
+        #       depends: bux
+        #
+        $* bix 2>>~%EOE%;
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add bix/1.0.0
+          trace: collect_build_prerequisites: begin bix/1.0.0
+          %.*
+          trace: collect_build: add libbar/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bix/1.0.0
+          trace: collect_build: add bar/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency bar/1.0.0 of dependent bix/1.0.0
+          trace: postponed_configurations::add: create {bix | libbar->{bix/1,1} bar->{bix/1,1}}
+          trace: collect_build_prerequisites: postpone bix/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {bix | libbar->{bix/1,1} bar->{bix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {bix | libbar->{bix/1,1} bar->{bix/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbar/1.0.0
+          trace: collect_build_prerequisites: end libbar/1.0.0
+          trace: collect_build_prerequisites: begin bar/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+          trace: postponed_configurations::add: add {bar 1,1: libbar} to {bix | libbar->{bix/1,1} bar->{bix/1,1}}?
+          trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bar/1.0.0 is negotiated
+          trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bar/1.0.0 is already (being) recursively collected, skipping
+          trace: collect_build_prerequisites: end bar/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bix/1.0.0
+          trace: collect_build_prerequisites: resume bix/1.0.0
+          %.*
+          trace: collect_build: add bux/1.0.0
+          trace: collect_build_prerequisites: no cfg-clause for dependency bux/1.0.0 of dependent bix/1.0.0
+          trace: collect_build_prerequisites: begin bux/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bux/1.0.0
+          trace: postponed_configurations::add: add {bux 1,1: libbar} to {bar bix | libbar->{bar/1,1 bix/1,1} bar->{bix/1,1}}?
+          %.*
+          trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bux/1.0.0 is negotiated
+          trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bux/1.0.0 is already (being) recursively collected, skipping
+          trace: collect_build_prerequisites: end bux/1.0.0
+          trace: collect_build_prerequisites: end bix/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {bar bix bux | libbar->{bar/1,1 bix/1,1 bux/1,1} bar->{bix/1,1}}!
+          trace: collect_build_postponed (1): end {bix | libbar->{bix/1,1} bar->{bix/1,1}}
+          trace: collect_build_postponed (0): end
+          trace: execute_plan: simulate: yes
+          %.*
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bix configured 1.0.0
+            bar configured 1.0.0
+              libbar configured 1.0.0
+            bux configured 1.0.0
+              libbar configured 1.0.0
+            libbar configured 1.0.0
+          EOO
+
+        $pkg_drop bix
+      }
+
+      : postponed-alts
+      :
+      {
+        +$clone_cfg
+
+        : with-premature
+        :
+        {
+          $clone_cfg;
+
+          $* fux boo 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add fux/1.0.0
+            trace: collect_build: add boo/1.0.0
+            trace: collect_build_prerequisites: begin fux/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent fux/1.0.0
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_prerequisites: end fux/1.0.0
+            trace: collect_build_prerequisites: begin boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: alt-postpone dependent boo/1.0.0 since max index is reached: 0
+              info: dependency alternative: libbar
+            trace: collect_build_prerequisites: postpone boo/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (0): index 1 collect alt-postponed boo/1.0.0
+            trace: collect_build_prerequisites: resume boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: alt-postpone dependent boo/1.0.0 since max index is reached: 1
+              info: dependency alternative: libfoo
+            {
+              require
+              {
+                config.libfoo.extras = true
+              }
+            }
+            trace: collect_build_prerequisites: postpone boo/1.0.0
+            trace: collect_build_postponed (0): index 2 collect alt-postponed boo/1.0.0
+            trace: collect_build_prerequisites: resume boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency libfoo/1.0.0 of dependent boo/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (libfoo), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add fux/1.0.0
+            trace: collect_build: add boo/1.0.0
+            trace: collect_build_prerequisites: begin fux/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent fux/1.0.0
+            trace: collect_build_prerequisites: end fux/1.0.0
+            trace: collect_build_prerequisites: begin boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: alt-postpone dependent boo/1.0.0 since max index is reached: 0
+              info: dependency alternative: libbar
+            trace: collect_build_prerequisites: postpone boo/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (0): index 1 collect alt-postponed boo/1.0.0
+            trace: collect_build_prerequisites: resume boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: alt-postpone dependent boo/1.0.0 since max index is reached: 1
+              info: dependency alternative: libfoo
+            {
+              require
+              {
+                config.libfoo.extras = true
+              }
+            }
+            trace: collect_build_prerequisites: postpone boo/1.0.0
+            trace: collect_build_postponed (0): index 2 collect alt-postponed boo/1.0.0
+            trace: collect_build_prerequisites: resume boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent boo/1.0.0
+            trace: postponed_configurations::add: create {boo | libfoo->{boo/1,2}}
+            trace: collect_build_prerequisites: postpone boo/1.0.0
+            trace: collect_build_postponed (1): begin {boo | libfoo->{boo/1,2}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {boo | libfoo->{boo/1,2}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent boo/1.0.0
+            trace: collect_build_prerequisites: resume boo/1.0.0
+            trace: collect_build_prerequisites: end boo/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {boo | libfoo->{boo/1,2}}!
+            trace: collect_build_postponed (1): end {boo | libfoo->{boo/1,2}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !fux configured 1.0.0
+              libfoo configured 1.0.0
+            !boo configured 1.0.0
+              libfoo configured 1.0.0
+            EOO
+
+          $pkg_drop fux boo
+        }
+
+        : with-premature-complex
+        :
+        {
+          $clone_cfg;
+
+          $* fux bex fix biz 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add fux/1.0.0
+            trace: collect_build: add bex/1.0.0
+            trace: collect_build: add fix/1.0.0
+            trace: collect_build: add biz/1.0.0
+            trace: collect_build_prerequisites: begin fux/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent fux/1.0.0
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_prerequisites: end fux/1.0.0
+            trace: collect_build_prerequisites: begin bex/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent bex/1.0.0
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_prerequisites: end bex/1.0.0
+            trace: collect_build_prerequisites: begin fix/1.0.0
+            %.*
+            trace: collect_build: add foo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency foo/1.0.0 of dependent fix/1.0.0
+            trace: postponed_configurations::add: create {fix | foo->{fix/1,1}}
+            trace: collect_build_prerequisites: postpone fix/1.0.0
+            trace: collect_build_prerequisites: begin biz/1.0.0
+            %.*
+            trace: collect_build: add boo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency boo/1.0.0 of dependent biz/1.0.0
+            trace: postponed_configurations::add: create {biz | boo->{biz/1,1}}
+            trace: collect_build_prerequisites: postpone biz/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {fix | foo->{fix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {fix | foo->{fix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin foo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (libfoo), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add fux/1.0.0
+            trace: collect_build: add bex/1.0.0
+            trace: collect_build: add fix/1.0.0
+            trace: collect_build: add biz/1.0.0
+            trace: collect_build_prerequisites: begin fux/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent fux/1.0.0
+            trace: collect_build_prerequisites: end fux/1.0.0
+            trace: collect_build_prerequisites: begin bex/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent bex/1.0.0
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_prerequisites: end bex/1.0.0
+            trace: collect_build_prerequisites: begin fix/1.0.0
+            %.*
+            trace: collect_build: add foo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency foo/1.0.0 of dependent fix/1.0.0
+            trace: postponed_configurations::add: create {fix | foo->{fix/1,1}}
+            trace: collect_build_prerequisites: postpone fix/1.0.0
+            trace: collect_build_prerequisites: begin biz/1.0.0
+            %.*
+            trace: collect_build: add boo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency boo/1.0.0 of dependent biz/1.0.0
+            trace: postponed_configurations::add: create {biz | boo->{biz/1,1}}
+            trace: collect_build_prerequisites: postpone biz/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {fix | foo->{fix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {fix | foo->{fix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin foo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+            trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+            trace: collect_build_prerequisites: postpone foo/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent fix/1.0.0
+            trace: collect_build_prerequisites: resume fix/1.0.0
+            trace: collect_build_prerequisites: end fix/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {fix | foo->{fix/1,1}}!
+            trace: collect_build_postponed (2): begin {biz | boo->{biz/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {biz | boo->{biz/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: alt-postpone dependent boo/1.0.0 since max index is reached: 0
+              info: dependency alternative: libbar
+            trace: collect_build_prerequisites: postpone boo/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent biz/1.0.0
+            trace: collect_build_prerequisites: resume biz/1.0.0
+            trace: collect_build_prerequisites: end biz/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {biz | boo->{biz/1,1}}!
+            trace: collect_build_postponed (3): begin {foo | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {foo | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+            trace: collect_build_prerequisites: resume foo/1.0.0
+            trace: collect_build_prerequisites: end foo/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {foo | libfoo->{foo/1,1}}!
+            trace: collect_build_postponed (3): index 1 collect alt-postponed boo/1.0.0
+            trace: collect_build_prerequisites: resume boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent boo/1.0.0
+            trace: collect_build_prerequisites: end boo/1.0.0
+            trace: collect_build_postponed (3): end {foo | libfoo->{foo/1,1}}
+            trace: collect_build_postponed (2): end {biz | boo->{biz/1,1}}
+            trace: collect_build_postponed (1): end {fix | foo->{fix/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !fux configured 1.0.0
+              libfoo configured 1.0.0
+            !fix configured 1.0.0
+              foo configured 1.0.0
+                libfoo configured 1.0.0
+            !bex configured 1.0.0
+              libbar configured 1.0.0
+            !biz configured 1.0.0
+              boo configured 1.0.0
+                libbar configured 1.0.0
+            EOO
+
+          $pkg_drop fux bex fix biz
+        }
+
+        : up-negotiate
+        :
+        {
+          $clone_cfg;
+
+          $* foo boo 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add foo/1.0.0
+            trace: collect_build: add boo/1.0.0
+            trace: collect_build_prerequisites: begin foo/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+            trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+            trace: collect_build_prerequisites: postpone foo/1.0.0
+            trace: collect_build_prerequisites: begin boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: alt-postpone dependent boo/1.0.0 since max index is reached: 0
+              info: dependency alternative: libbar
+            trace: collect_build_prerequisites: postpone boo/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {foo | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {foo | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+            trace: collect_build_prerequisites: resume foo/1.0.0
+            trace: collect_build_prerequisites: end foo/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {foo | libfoo->{foo/1,1}}!
+            trace: collect_build_postponed (1): index 1 collect alt-postponed boo/1.0.0
+            trace: collect_build_prerequisites: resume boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: alt-postpone dependent boo/1.0.0 since max index is reached: 1
+              info: dependency alternative: libfoo
+            {
+              require
+              {
+                config.libfoo.extras = true
+              }
+            }
+            trace: collect_build_prerequisites: postpone boo/1.0.0
+            trace: collect_build_postponed (1): index 2 collect alt-postponed boo/1.0.0
+            trace: collect_build_prerequisites: resume boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent boo/1.0.0
+            trace: postponed_configurations::add: add {boo 1,2: libfoo} to {foo | libfoo->{foo/1,1}}!
+            %.*
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent boo/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libfoo/1.0.0 of dependent boo/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end boo/1.0.0
+            trace: collect_build_postponed (1): end {foo | libfoo->{foo/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !foo configured 1.0.0
+              libfoo configured 1.0.0
+            !boo configured 1.0.0
+              libfoo configured 1.0.0
+            EOO
+
+          $pkg_drop foo boo
+        }
+
+        : after-negotiation
+        :
+        {
+          $clone_cfg;
+
+          $* foo biz 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add foo/1.0.0
+            trace: collect_build: add biz/1.0.0
+            trace: collect_build_prerequisites: begin foo/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+            trace: postponed_configurations::add: create {foo | libfoo->{foo/1,1}}
+            trace: collect_build_prerequisites: postpone foo/1.0.0
+            trace: collect_build_prerequisites: begin biz/1.0.0
+            %.*
+            trace: collect_build: add boo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency boo/1.0.0 of dependent biz/1.0.0
+            trace: postponed_configurations::add: create {biz | boo->{biz/1,1}}
+            trace: collect_build_prerequisites: postpone biz/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {foo | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {foo | libfoo->{foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+            trace: collect_build_prerequisites: resume foo/1.0.0
+            trace: collect_build_prerequisites: end foo/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {foo | libfoo->{foo/1,1}}!
+            trace: collect_build_postponed (2): begin {biz | boo->{biz/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {biz | boo->{biz/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: alt-postpone dependent boo/1.0.0 since max index is reached: 0
+              info: dependency alternative: libbar
+            trace: collect_build_prerequisites: postpone boo/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent biz/1.0.0
+            trace: collect_build_prerequisites: resume biz/1.0.0
+            trace: collect_build_prerequisites: end biz/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {biz | boo->{biz/1,1}}!
+            trace: collect_build_postponed (2): index 1 collect alt-postponed boo/1.0.0
+            trace: collect_build_prerequisites: resume boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: alt-postpone dependent boo/1.0.0 since max index is reached: 1
+              info: dependency alternative: libfoo
+            {
+              require
+              {
+                config.libfoo.extras = true
+              }
+            }
+            trace: collect_build_prerequisites: postpone boo/1.0.0
+            trace: collect_build_postponed (2): index 2 collect alt-postponed boo/1.0.0
+            trace: collect_build_prerequisites: resume boo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent boo/1.0.0
+            trace: postponed_configurations::add: add {boo 1,2: libfoo} to {foo | libfoo->{foo/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent boo/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libfoo/1.0.0 of dependent boo/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end boo/1.0.0
+            trace: collect_build_postponed (2): end {biz | boo->{biz/1,1}}
+            trace: collect_build_postponed (1): end {foo | libfoo->{foo/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !foo configured 1.0.0
+              libfoo configured 1.0.0
+            !biz configured 1.0.0
+              boo configured 1.0.0
+                libfoo configured 1.0.0
+            EOO
+
+          $pkg_drop foo biz
+        }
+      }
+
+      : bogus-postponment
+      :
+      {
+        $clone_cfg;
+
+        #  Dependencies:
+        #
+        #  tax: depends: libbar(c)
+        #       depends: libfoo
+        #
+        #  toz/0.1.0:
+        #
+        #  toz/1.0.0: depends: libbaz(c)
+        #             depends: libfoo(c)
+        #             depends: libbar(c)
+        #
+        #  tez: depends: libbox(c)
+        #       depends: toz == 0.1.0 (c)
+        #       depends: libbar(c)
+        #
+        $* tax toz tez 2>>~%EOE%;
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add tax/1.0.0
+          trace: collect_build: add toz/1.0.0
+          trace: collect_build: add tez/1.0.0
+          trace: collect_build_prerequisites: begin tax/1.0.0
+          %.*
+          trace: collect_build: add libbar/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tax/1.0.0
+          trace: postponed_configurations::add: create {tax | libbar->{tax/1,1}}
+          trace: collect_build_prerequisites: postpone tax/1.0.0
+          trace: collect_build_prerequisites: begin toz/1.0.0
+          %.*
+          trace: collect_build: add libbaz/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbaz/1.0.0 of dependent toz/1.0.0
+          trace: postponed_configurations::add: create {toz | libbaz->{toz/1,1}}
+          trace: collect_build_prerequisites: postpone toz/1.0.0
+          trace: collect_build_prerequisites: begin tez/1.0.0
+          %.*
+          trace: collect_build: add libbox/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/1.0.0
+          trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}}
+          trace: collect_build_prerequisites: postpone tez/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {tax | libbar->{tax/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {tax | libbar->{tax/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbar/1.0.0
+          trace: collect_build_prerequisites: end libbar/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tax/1.0.0
+          trace: collect_build_prerequisites: resume tax/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent tax/1.0.0
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_prerequisites: end tax/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {tax | libbar->{tax/1,1}}!
+          trace: collect_build_postponed (2): begin {toz | libbaz->{toz/1,1}}
+          %.*
+          trace: collect_build_postponed (2): cfg-negotiate begin {toz | libbaz->{toz/1,1}}
+          %.*
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbaz/1.0.0
+          trace: collect_build_prerequisites: end libbaz/1.0.0
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent toz/1.0.0
+          trace: collect_build_prerequisites: resume toz/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cannot cfg-postpone dependency libfoo/1.0.0 of dependent toz/1.0.0 (collected prematurely), throwing postpone_dependency
+          trace: pkg_build: collection failed due to prematurely collected dependency (libfoo), retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add tax/1.0.0
+          trace: collect_build: add toz/1.0.0
+          trace: collect_build: add tez/1.0.0
+          trace: collect_build_prerequisites: begin tax/1.0.0
+          %.*
+          trace: collect_build: add libbar/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tax/1.0.0
+          trace: postponed_configurations::add: create {tax | libbar->{tax/1,1}}
+          trace: collect_build_prerequisites: postpone tax/1.0.0
+          trace: collect_build_prerequisites: begin toz/1.0.0
+          %.*
+          trace: collect_build: add libbaz/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbaz/1.0.0 of dependent toz/1.0.0
+          trace: postponed_configurations::add: create {toz | libbaz->{toz/1,1}}
+          trace: collect_build_prerequisites: postpone toz/1.0.0
+          trace: collect_build_prerequisites: begin tez/1.0.0
+          %.*
+          trace: collect_build: add libbox/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/1.0.0
+          trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}}
+          trace: collect_build_prerequisites: postpone tez/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {tax | libbar->{tax/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {tax | libbar->{tax/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbar/1.0.0
+          trace: collect_build_prerequisites: end libbar/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tax/1.0.0
+          trace: collect_build_prerequisites: resume tax/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent tax/1.0.0
+          trace: collect_build_prerequisites: end tax/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {tax | libbar->{tax/1,1}}!
+          trace: collect_build_postponed (2): begin {toz | libbaz->{toz/1,1}}
+          %.*
+          trace: collect_build_postponed (2): cfg-negotiate begin {toz | libbaz->{toz/1,1}}
+          %.*
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbaz/1.0.0
+          trace: collect_build_prerequisites: end libbaz/1.0.0
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent toz/1.0.0
+          trace: collect_build_prerequisites: resume toz/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/1.0.0
+          trace: postponed_configurations::add: create {toz | libfoo->{toz/2,1}}
+          trace: collect_build_prerequisites: postpone toz/1.0.0
+          trace: collect_build_postponed (2): cfg-negotiate end {toz | libbaz->{toz/1,1}}!
+          trace: collect_build_postponed (3): begin {tez | libbox->{tez/1,1}}
+          %.*
+          trace: collect_build_postponed (3): cfg-negotiate begin {tez | libbox->{tez/1,1}}
+          %.*
+          trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbox/1.0.0
+          trace: collect_build_prerequisites: end libbox/1.0.0
+          trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tez/1.0.0
+          trace: collect_build_prerequisites: resume tez/1.0.0
+          %.*
+          trace: collect_build: pick toz/0.1.0 over toz/1.0.0
+          trace: collect_build: toz/1.0.0 package version needs to be replaced with toz/0.1.0
+          trace: pkg_build: collection failed due to package version replacement, retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add tax/1.0.0
+          trace: collect_build: apply version replacement for toz/1.0.0
+          trace: collect_build: replacement: toz/0.1.0
+          trace: collect_build: add toz/0.1.0
+          trace: collect_build: add tez/1.0.0
+          trace: collect_build_prerequisites: begin tax/1.0.0
+          %.*
+          trace: collect_build: add libbar/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tax/1.0.0
+          trace: postponed_configurations::add: create {tax | libbar->{tax/1,1}}
+          trace: collect_build_prerequisites: postpone tax/1.0.0
+          trace: collect_build_prerequisites: begin toz/0.1.0
+          trace: collect_build_prerequisites: end toz/0.1.0
+          trace: collect_build_prerequisites: begin tez/1.0.0
+          %.*
+          trace: collect_build: add libbox/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/1.0.0
+          trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}}
+          trace: collect_build_prerequisites: postpone tez/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {tax | libbar->{tax/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {tax | libbar->{tax/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbar/1.0.0
+          trace: collect_build_prerequisites: end libbar/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tax/1.0.0
+          trace: collect_build_prerequisites: resume tax/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent tax/1.0.0
+          trace: collect_build_prerequisites: end tax/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {tax | libbar->{tax/1,1}}!
+          trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}}
+          %.*
+          trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}}
+          %.*
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbox/1.0.0
+          trace: collect_build_prerequisites: end libbox/1.0.0
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/1.0.0
+          trace: collect_build_prerequisites: resume tez/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cannot cfg-postpone dependency toz/0.1.0 of dependent tez/1.0.0 (collected prematurely), throwing postpone_dependency
+          trace: pkg_build: collection failed due to prematurely collected dependency (toz), retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add tax/1.0.0
+          trace: collect_build: apply version replacement for toz/1.0.0
+          trace: collect_build: replacement: toz/0.1.0
+          trace: collect_build: add toz/0.1.0
+          trace: collect_build: add tez/1.0.0
+          trace: collect_build_prerequisites: begin tax/1.0.0
+          %.*
+          trace: collect_build: add libbar/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tax/1.0.0
+          trace: postponed_configurations::add: create {tax | libbar->{tax/1,1}}
+          trace: collect_build_prerequisites: postpone tax/1.0.0
+          trace: pkg_build: dep-postpone user-specified toz
+          trace: collect_build_prerequisites: begin tez/1.0.0
+          %.*
+          trace: collect_build: add libbox/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/1.0.0
+          trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}}
+          trace: collect_build_prerequisites: postpone tez/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {tax | libbar->{tax/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {tax | libbar->{tax/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbar/1.0.0
+          trace: collect_build_prerequisites: end libbar/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tax/1.0.0
+          trace: collect_build_prerequisites: resume tax/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent tax/1.0.0
+          trace: collect_build_prerequisites: end tax/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {tax | libbar->{tax/1,1}}!
+          trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}}
+          %.*
+          trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}}
+          %.*
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbox/1.0.0
+          trace: collect_build_prerequisites: end libbox/1.0.0
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/1.0.0
+          trace: collect_build_prerequisites: resume tez/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency toz/0.1.0 of dependent tez/1.0.0
+          trace: postponed_configurations::add: create {tez | toz->{tez/2,1}}
+          trace: collect_build_prerequisites: postpone tez/1.0.0
+          trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1}}!
+          trace: collect_build_postponed (3): begin {tez | toz->{tez/2,1}}
+          %.*
+          trace: collect_build_postponed (3): cfg-negotiate begin {tez | toz->{tez/2,1}}
+          %.*
+          trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin toz/0.1.0
+          trace: collect_build_prerequisites: end toz/0.1.0
+          trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tez/1.0.0
+          trace: collect_build_prerequisites: resume tez/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0
+          trace: postponed_configurations::add: add {tez 3,1: libbar} to {tax | libbar->{tax/1,1}}!
+          trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated
+          trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping
+          trace: collect_build_prerequisites: end tez/1.0.0
+          trace: collect_build_postponed (3): cfg-negotiate end {tez | toz->{tez/2,1}}!
+          trace: collect_build_postponed (3): erase bogus postponement libfoo
+          trace: collect_build_postponed (3): bogus postponements erased, throwing
+          trace: pkg_build: collection failed due to bogus dependency collection postponement cancellation, retry from scratch
+          %.*
+          trace: pkg_build: refine package collection/plan execution from scratch
+          %.*
+          trace: collect_build: add tax/1.0.0
+          trace: collect_build: apply version replacement for toz/1.0.0
+          trace: collect_build: replacement: toz/0.1.0
+          trace: collect_build: add toz/0.1.0
+          trace: collect_build: add tez/1.0.0
+          trace: collect_build_prerequisites: begin tax/1.0.0
+          %.*
+          trace: collect_build: add libbar/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tax/1.0.0
+          trace: postponed_configurations::add: create {tax | libbar->{tax/1,1}}
+          trace: collect_build_prerequisites: postpone tax/1.0.0
+          trace: pkg_build: dep-postpone user-specified toz
+          trace: collect_build_prerequisites: begin tez/1.0.0
+          %.*
+          trace: collect_build: add libbox/1.0.0
+          trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tez/1.0.0
+          trace: postponed_configurations::add: create {tez | libbox->{tez/1,1}}
+          trace: collect_build_prerequisites: postpone tez/1.0.0
+          trace: collect_build_postponed (0): begin
+          trace: collect_build_postponed (1): begin {tax | libbar->{tax/1,1}}
+          %.*
+          trace: collect_build_postponed (1): cfg-negotiate begin {tax | libbar->{tax/1,1}}
+          %.*
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbar/1.0.0
+          trace: collect_build_prerequisites: end libbar/1.0.0
+          trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tax/1.0.0
+          trace: collect_build_prerequisites: resume tax/1.0.0
+          %.*
+          trace: collect_build: add libfoo/1.0.0
+          trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent tax/1.0.0
+          trace: collect_build_prerequisites: begin libfoo/1.0.0
+          trace: collect_build_prerequisites: end libfoo/1.0.0
+          trace: collect_build_prerequisites: end tax/1.0.0
+          trace: collect_build_postponed (1): cfg-negotiate end {tax | libbar->{tax/1,1}}!
+          trace: collect_build_postponed (2): begin {tez | libbox->{tez/1,1}}
+          %.*
+          trace: collect_build_postponed (2): cfg-negotiate begin {tez | libbox->{tez/1,1}}
+          %.*
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin libbox/1.0.0
+          trace: collect_build_prerequisites: end libbox/1.0.0
+          trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tez/1.0.0
+          trace: collect_build_prerequisites: resume tez/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency toz/0.1.0 of dependent tez/1.0.0
+          trace: postponed_configurations::add: create {tez | toz->{tez/2,1}}
+          trace: collect_build_prerequisites: postpone tez/1.0.0
+          trace: collect_build_postponed (2): cfg-negotiate end {tez | libbox->{tez/1,1}}!
+          trace: collect_build_postponed (3): begin {tez | toz->{tez/2,1}}
+          %.*
+          trace: collect_build_postponed (3): cfg-negotiate begin {tez | toz->{tez/2,1}}
+          %.*
+          trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+          trace: collect_build_prerequisites: begin toz/0.1.0
+          trace: collect_build_prerequisites: end toz/0.1.0
+          trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+          trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tez/1.0.0
+          trace: collect_build_prerequisites: resume tez/1.0.0
+          %.*
+          trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tez/1.0.0
+          trace: postponed_configurations::add: add {tez 3,1: libbar} to {tax | libbar->{tax/1,1}}!
+          trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tez/1.0.0 is negotiated
+          trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tez/1.0.0 is already (being) recursively collected, skipping
+          trace: collect_build_prerequisites: end tez/1.0.0
+          trace: collect_build_postponed (3): cfg-negotiate end {tez | toz->{tez/2,1}}!
+          trace: collect_build_postponed (3): end {tez | toz->{tez/2,1}}
+          trace: collect_build_postponed (2): end {tez | libbox->{tez/1,1}}
+          trace: collect_build_postponed (1): end {tax | libbar->{tax/1,1}}
+          trace: collect_build_postponed (0): end
+          trace: execute_plan: simulate: yes
+          %.*
+          EOE
+
+        $pkg_status -r >>EOO;
+          !toz configured 0.1.0 available 1.0.0 0.2.0
+          !tax configured 1.0.0
+            libbar configured 1.0.0
+            libfoo configured 1.0.0
+          !tez configured 1.0.0
+            libbar configured 1.0.0
+            libbox configured 1.0.0
+            !toz configured 0.1.0 available 1.0.0 0.2.0
+          EOO
+
+        $pkg_drop tax toz tez
+      }
+    }
+
+    : cycle
+    :
+    {
+      +$clone_cfg
+
+      : direct
+      :
+      {
+        +$clone_cfg
+
+        : args-tex-tix
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  tex: depends: libbar(c)
+          #       depends: libfoo(c)
+          #
+          #  tix: depends: libbar(c)
+          #       depends: tex(c)
+          #
+          $* tex tix 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build: add tix/1.0.0
+            trace: collect_build_prerequisites: begin tex/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_prerequisites: begin tix/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tix/1.0.0
+            trace: postponed_configurations::add: add {tix 1,1: libbar} to {tex | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: postpone tix/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tex tix | libbar->{tex/1,1 tix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tex tix | libbar->{tex/1,1 tix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+            trace: collect_build_prerequisites: resume tix/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency tex/1.0.0 of dependent tix/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (tex), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build: add tix/1.0.0
+            trace: pkg_build: dep-postpone user-specified tex
+            trace: collect_build_prerequisites: begin tix/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tix/1.0.0
+            trace: postponed_configurations::add: create {tix | libbar->{tix/1,1}}
+            trace: collect_build_prerequisites: postpone tix/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tix | libbar->{tix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tix | libbar->{tix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+            trace: collect_build_prerequisites: resume tix/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency tex/1.0.0 of dependent tix/1.0.0
+            trace: postponed_configurations::add: create {tix | tex->{tix/2,1}}
+            trace: collect_build_prerequisites: postpone tix/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tix | libbar->{tix/1,1}}!
+            trace: collect_build_postponed (2): begin {tix | tex->{tix/2,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {tix | tex->{tix/2,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin tex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: add {tex 1,1: libbar} to {tix | libbar->{tix/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tex/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tex/1.0.0 is already (being) recursively collected, skipping
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+            trace: collect_build_prerequisites: resume tix/1.0.0
+            trace: collect_build_prerequisites: end tix/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {tix | tex->{tix/2,1}}!
+            trace: collect_build_postponed (3): begin {tex | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {tex | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            trace: collect_build_prerequisites: end tex/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {tex | libfoo->{tex/2,1}}!
+            trace: collect_build_postponed (3): end {tex | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (2): end {tix | tex->{tix/2,1}}
+            trace: collect_build_postponed (1): end {tix | libbar->{tix/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !tex configured 1.0.0
+              libbar configured 1.0.0
+              libfoo configured 1.0.0
+            !tix configured 1.0.0
+              libbar configured 1.0.0
+              !tex configured 1.0.0
+                libbar configured 1.0.0
+                libfoo configured 1.0.0
+            EOO
+
+          $pkg_drop tex tix
+        }
+
+        : args-tix
+        :
+        : As above but with the different command-line arguments which results
+        : in the different cluster list at the moment of the cycle detection.
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  tex: depends: libbar(c)
+          #       depends: libfoo(c)
+          #
+          #  tix: depends: libbar(c)
+          #       depends: tex(c)
+          #
+          $* tix 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tix/1.0.0
+            trace: collect_build_prerequisites: begin tix/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tix/1.0.0
+            trace: postponed_configurations::add: create {tix | libbar->{tix/1,1}}
+            trace: collect_build_prerequisites: postpone tix/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tix | libbar->{tix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tix | libbar->{tix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+            trace: collect_build_prerequisites: resume tix/1.0.0
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency tex/1.0.0 of dependent tix/1.0.0
+            trace: postponed_configurations::add: create {tix | tex->{tix/2,1}}
+            trace: collect_build_prerequisites: postpone tix/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tix | libbar->{tix/1,1}}!
+            trace: collect_build_postponed (2): begin {tix | tex->{tix/2,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {tix | tex->{tix/2,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin tex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: add {tex 1,1: libbar} to {tix | libbar->{tix/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tex/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tex/1.0.0 is already (being) recursively collected, skipping
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+            trace: collect_build_prerequisites: resume tix/1.0.0
+            trace: collect_build_prerequisites: end tix/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {tix | tex->{tix/2,1}}!
+            trace: collect_build_postponed (3): begin {tex | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {tex | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            trace: collect_build_prerequisites: end tex/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {tex | libfoo->{tex/2,1}}!
+            trace: collect_build_postponed (3): end {tex | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (2): end {tix | tex->{tix/2,1}}
+            trace: collect_build_postponed (1): end {tix | libbar->{tix/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !tix configured 1.0.0
+              libbar configured 1.0.0
+              tex configured 1.0.0
+                libbar configured 1.0.0
+                libfoo configured 1.0.0
+            EOO
+
+          $pkg_drop tix
+        }
+
+        : args-tex-tix-tux
+        :
+        : Here tux requires tix/0.1.0 which has no dependencies.
+        :
+        {
+          $clone_cfg;
+
+          $* tex tix tux 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build: add tix/1.0.0
+            trace: collect_build: add tux/1.0.0
+            trace: collect_build_prerequisites: begin tex/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_prerequisites: begin tix/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tix/1.0.0
+            trace: postponed_configurations::add: add {tix 1,1: libbar} to {tex | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: postpone tix/1.0.0
+            trace: collect_build_prerequisites: begin tux/1.0.0
+            %.*
+            trace: collect_build: add libbox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tux/1.0.0
+            trace: postponed_configurations::add: create {tux | libbox->{tux/1,1}}
+            trace: collect_build_prerequisites: postpone tux/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tex tix | libbar->{tex/1,1 tix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tex tix | libbar->{tex/1,1 tix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+            trace: collect_build_prerequisites: resume tix/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency tex/1.0.0 of dependent tix/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (tex), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build: add tix/1.0.0
+            trace: collect_build: add tux/1.0.0
+            trace: pkg_build: dep-postpone user-specified tex
+            trace: collect_build_prerequisites: begin tix/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tix/1.0.0
+            trace: postponed_configurations::add: create {tix | libbar->{tix/1,1}}
+            trace: collect_build_prerequisites: postpone tix/1.0.0
+            trace: collect_build_prerequisites: begin tux/1.0.0
+            %.*
+            trace: collect_build: add libbox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tux/1.0.0
+            trace: postponed_configurations::add: create {tux | libbox->{tux/1,1}}
+            trace: collect_build_prerequisites: postpone tux/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tix | libbar->{tix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tix | libbar->{tix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+            trace: collect_build_prerequisites: resume tix/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency tex/1.0.0 of dependent tix/1.0.0
+            trace: postponed_configurations::add: create {tix | tex->{tix/2,1}}
+            trace: collect_build_prerequisites: postpone tix/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tix | libbar->{tix/1,1}}!
+            trace: collect_build_postponed (2): begin {tux | libbox->{tux/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {tux | libbox->{tux/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbox/1.0.0
+            trace: collect_build_prerequisites: end libbox/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tux/1.0.0
+            trace: collect_build_prerequisites: resume tux/1.0.0
+            %.*
+            trace: collect_build: pick tix/0.1.0 over tix/1.0.0
+            trace: collect_build: tix/1.0.0 package version needs to be replaced with tix/0.1.0
+            trace: pkg_build: collection failed due to package version replacement, retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build: apply version replacement for tix/1.0.0
+            trace: collect_build: replacement: tix/0.1.0
+            trace: collect_build: add tix/0.1.0
+            trace: collect_build: add tux/1.0.0
+            trace: pkg_build: dep-postpone user-specified tex
+            trace: collect_build_prerequisites: begin tix/0.1.0
+            trace: collect_build_prerequisites: end tix/0.1.0
+            trace: collect_build_prerequisites: begin tux/1.0.0
+            %.*
+            trace: collect_build: add libbox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tux/1.0.0
+            trace: postponed_configurations::add: create {tux | libbox->{tux/1,1}}
+            trace: collect_build_prerequisites: postpone tux/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tux | libbox->{tux/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tux | libbox->{tux/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbox/1.0.0
+            trace: collect_build_prerequisites: end libbox/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tux/1.0.0
+            trace: collect_build_prerequisites: resume tux/1.0.0
+            %.*
+            trace: collect_build_prerequisites: no cfg-clause for dependency tix/0.1.0 of dependent tux/1.0.0
+            trace: collect_build_prerequisites: end tux/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tux | libbox->{tux/1,1}}!
+            trace: collect_build_postponed (1): erase bogus postponement tex
+            trace: collect_build_postponed (1): bogus postponements erased, throwing
+            trace: pkg_build: collection failed due to bogus dependency collection postponement cancellation, retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build: apply version replacement for tix/1.0.0
+            trace: collect_build: replacement: tix/0.1.0
+            trace: collect_build: add tix/0.1.0
+            trace: collect_build: add tux/1.0.0
+            trace: collect_build_prerequisites: begin tex/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_prerequisites: begin tix/0.1.0
+            trace: collect_build_prerequisites: end tix/0.1.0
+            trace: collect_build_prerequisites: begin tux/1.0.0
+            %.*
+            trace: collect_build: add libbox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent tux/1.0.0
+            trace: postponed_configurations::add: create {tux | libbox->{tux/1,1}}
+            trace: collect_build_prerequisites: postpone tux/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tex | libbar->{tex/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tex | libbar->{tex/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tex | libbar->{tex/1,1}}!
+            trace: collect_build_postponed (2): begin {tux | libbox->{tux/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {tux | libbox->{tux/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbox/1.0.0
+            trace: collect_build_prerequisites: end libbox/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tux/1.0.0
+            trace: collect_build_prerequisites: resume tux/1.0.0
+            %.*
+            trace: collect_build_prerequisites: no cfg-clause for dependency tix/0.1.0 of dependent tux/1.0.0
+            trace: collect_build_prerequisites: end tux/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {tux | libbox->{tux/1,1}}!
+            trace: collect_build_postponed (3): begin {tex | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {tex | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            trace: collect_build_prerequisites: end tex/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {tex | libfoo->{tex/2,1}}!
+            trace: collect_build_postponed (3): end {tex | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (2): end {tux | libbox->{tux/1,1}}
+            trace: collect_build_postponed (1): end {tex | libbar->{tex/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !tex configured 1.0.0
+              libbar configured 1.0.0
+              libfoo configured 1.0.0
+            !tix configured 0.1.0 available 1.0.0
+            !tux configured 1.0.0
+              libbox configured 1.0.0
+              !tix configured 0.1.0 available 1.0.0
+            EOO
+
+          $pkg_drop tex tix tux
+        }
+
+        : args-tex-tiz
+        :
+        : Note that tiz is a correct version of tix, which fixes the
+        : configuration cycle.
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  tex: depends: libbar(c)
+          #       depends: libfoo(c)
+          #
+          #  tiz: depends: tex(c)
+          #       depends: libbar(c)
+          #
+          $* tex tiz 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build: add tiz/1.0.0
+            trace: collect_build_prerequisites: begin tex/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_prerequisites: begin tiz/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency tex/1.0.0 of dependent tiz/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (tex), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build: add tiz/1.0.0
+            trace: pkg_build: dep-postpone user-specified tex
+            trace: collect_build_prerequisites: begin tiz/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency tex/1.0.0 of dependent tiz/1.0.0
+            trace: postponed_configurations::add: create {tiz | tex->{tiz/1,1}}
+            trace: collect_build_prerequisites: postpone tiz/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tiz | tex->{tiz/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tiz | tex->{tiz/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin tex/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tiz/1.0.0
+            trace: collect_build_prerequisites: resume tiz/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tiz/1.0.0
+            trace: postponed_configurations::add: add {tiz 2,1: libbar} to {tex | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: postpone tiz/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tiz | tex->{tiz/1,1}}!
+            trace: collect_build_postponed (2): begin {tex tiz | libbar->{tex/1,1 tiz/2,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {tex tiz | libbar->{tex/1,1 tiz/2,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tiz/1.0.0
+            trace: collect_build_prerequisites: resume tiz/1.0.0
+            trace: collect_build_prerequisites: end tiz/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {tex tiz | libbar->{tex/1,1 tiz/2,1}}!
+            trace: collect_build_postponed (3): begin {tex | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {tex | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            trace: collect_build_prerequisites: end tex/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {tex | libfoo->{tex/2,1}}!
+            trace: collect_build_postponed (3): end {tex | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (2): end {tex tiz | libbar->{tex/1,1 tiz/2,1}}
+            trace: collect_build_postponed (1): end {tiz | tex->{tiz/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !tex configured 1.0.0
+              libbar configured 1.0.0
+              libfoo configured 1.0.0
+            !tiz configured 1.0.0
+              libbar configured 1.0.0
+              !tex configured 1.0.0
+                libbar configured 1.0.0
+                libfoo configured 1.0.0
+            EOO
+
+          $pkg_drop tex tiz
+        }
+
+        : args-tiz
+        :
+        : Note that tiz is a correct version of tix, which fixes the
+        : configuration cycle.
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  tex: depends: libbar(c)
+          #       depends: libfoo(c)
+          #
+          #  tiz: depends: tex(c)
+          #       depends: libbar(c)
+          #
+          $* tiz 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tiz/1.0.0
+            trace: collect_build_prerequisites: begin tiz/1.0.0
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency tex/1.0.0 of dependent tiz/1.0.0
+            trace: postponed_configurations::add: create {tiz | tex->{tiz/1,1}}
+            trace: collect_build_prerequisites: postpone tiz/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tiz | tex->{tiz/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tiz | tex->{tiz/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin tex/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tiz/1.0.0
+            trace: collect_build_prerequisites: resume tiz/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tiz/1.0.0
+            trace: postponed_configurations::add: add {tiz 2,1: libbar} to {tex | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: postpone tiz/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tiz | tex->{tiz/1,1}}!
+            trace: collect_build_postponed (2): begin {tex tiz | libbar->{tex/1,1 tiz/2,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {tex tiz | libbar->{tex/1,1 tiz/2,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libfoo->{tex/2,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tiz/1.0.0
+            trace: collect_build_prerequisites: resume tiz/1.0.0
+            trace: collect_build_prerequisites: end tiz/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {tex tiz | libbar->{tex/1,1 tiz/2,1}}!
+            trace: collect_build_postponed (3): begin {tex | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {tex | libfoo->{tex/2,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            trace: collect_build_prerequisites: end tex/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {tex | libfoo->{tex/2,1}}!
+            trace: collect_build_postponed (3): end {tex | libfoo->{tex/2,1}}
+            trace: collect_build_postponed (2): end {tex tiz | libbar->{tex/1,1 tiz/2,1}}
+            trace: collect_build_postponed (1): end {tiz | tex->{tiz/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !tiz configured 1.0.0
+              libbar configured 1.0.0
+              tex configured 1.0.0
+                libbar configured 1.0.0
+                libfoo configured 1.0.0
+            EOO
+
+          $pkg_drop tiz
+        }
+
+        : depends-depends-conflict
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  tex: depends: libbar(c)
+          #       depends: libfoo(c)
+          #
+          #  toz: depends: libfoo(c)
+          #       depends: libbar(c)
+          #
+          $* tex toz/0.2.0 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tex/1.0.0
+            trace: collect_build: add toz/0.2.0
+            trace: collect_build_prerequisites: begin tex/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: create {tex | libbar->{tex/1,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_prerequisites: begin toz/0.2.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent toz/0.2.0
+            trace: postponed_configurations::add: create {toz | libfoo->{toz/1,1}}
+            trace: collect_build_prerequisites: postpone toz/0.2.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tex | libbar->{tex/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tex | libbar->{tex/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0
+            trace: postponed_configurations::add: add {tex 2,1: libfoo} to {toz | libfoo->{toz/1,1}}
+            trace: collect_build_prerequisites: postpone tex/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tex | libbar->{tex/1,1}}!
+            trace: collect_build_postponed (2): begin {tex toz | libfoo->{tex/2,1 toz/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {tex toz | libfoo->{tex/2,1 toz/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+            trace: collect_build_prerequisites: resume tex/1.0.0
+            trace: collect_build_prerequisites: end tex/1.0.0
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent toz/0.2.0
+            trace: collect_build_prerequisites: resume toz/0.2.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent toz/0.2.0
+            trace: postponed_configurations::add: add {toz 2,1: libbar} to {tex | libbar->{tex/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent toz/0.2.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent toz/0.2.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end toz/0.2.0
+            trace: collect_build_postponed (2): cfg-negotiate end {tex toz | libfoo->{tex/2,1 toz/1,1}}!
+            trace: collect_build_postponed (2): end {tex toz | libfoo->{tex/2,1 toz/1,1}}
+            trace: collect_build_postponed (1): end {tex | libbar->{tex/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !tex configured 1.0.0
+              libbar configured 1.0.0
+              libfoo configured 1.0.0
+            !toz configured !0.2.0 available 1.0.0
+              libbar configured 1.0.0
+              libfoo configured 1.0.0
+            EOO
+
+          $pkg_drop tex toz
+        }
+
+        : package-depends-conflict
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  baz: depends: {libbar libfoo} (c)
+          #
+          #  bac: depends: libbar(c)
+          #       depends: libbaz(c)
+          #       depends: libfoo(c)
+          #
+          #  bat: depends: libbaz(c)
+          #
+          $* baz bac bat 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add baz/1.0.0
+            trace: collect_build: add bac/1.0.0
+            trace: collect_build: add bat/1.0.0
+            trace: collect_build_prerequisites: begin baz/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent baz/1.0.0
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent baz/1.0.0
+            trace: postponed_configurations::add: create {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: postpone baz/1.0.0
+            trace: collect_build_prerequisites: begin bac/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bac/1.0.0
+            trace: postponed_configurations::add: add {bac 1,1: libbar} to {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: postpone bac/1.0.0
+            trace: collect_build_prerequisites: begin bat/1.0.0
+            %.*
+            trace: collect_build: add libbaz/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbaz/1.0.0 of dependent bat/1.0.0
+            trace: postponed_configurations::add: create {bat | libbaz->{bat/1,1}}
+            trace: collect_build_prerequisites: postpone bat/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {bac baz | libbar->{bac/1,1 baz/1,1} libfoo->{baz/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {bac baz | libbar->{bac/1,1 baz/1,1} libfoo->{baz/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bac/1.0.0
+            trace: collect_build_prerequisites: resume bac/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbaz/1.0.0 of dependent bac/1.0.0
+            trace: postponed_configurations::add: add {bac 2,1: libbaz} to {bat | libbaz->{bat/1,1}}
+            trace: collect_build_prerequisites: postpone bac/1.0.0
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent baz/1.0.0
+            trace: collect_build_prerequisites: resume baz/1.0.0
+            trace: collect_build_prerequisites: end baz/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {bac baz | libbar->{bac/1,1 baz/1,1} libfoo->{baz/1,1}}!
+            trace: collect_build_postponed (2): begin {bac bat | libbaz->{bac/2,1 bat/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {bac bat | libbaz->{bac/2,1 bat/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbaz/1.0.0
+            trace: collect_build_prerequisites: end libbaz/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bac/1.0.0
+            trace: collect_build_prerequisites: resume bac/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent bac/1.0.0
+            trace: postponed_configurations::add: add {bac 3,1: libfoo} to {bac baz | libbar->{bac/1,1 baz/1,1} libfoo->{baz/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bac/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libfoo/1.0.0 of dependent bac/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end bac/1.0.0
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bat/1.0.0
+            trace: collect_build_prerequisites: resume bat/1.0.0
+            trace: collect_build_prerequisites: end bat/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {bac bat | libbaz->{bac/2,1 bat/1,1}}!
+            trace: collect_build_postponed (2): end {bac bat | libbaz->{bac/2,1 bat/1,1}}
+            trace: collect_build_postponed (1): end {bac baz | libbar->{bac/1,1 baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !baz configured 1.0.0
+              libbar configured 1.0.0
+              libfoo configured 1.0.0
+            !bac configured 1.0.0
+              libbar configured 1.0.0
+              libbaz configured 1.0.0
+              libfoo configured 1.0.0
+            !bat configured 1.0.0
+              libbaz configured 1.0.0
+            EOO
+
+          $pkg_drop baz bac bat
+        }
+
+        : existing
+        :
+        {
+          +$clone_cfg
+
+          : dependency-new-downgrade
+          :
+          {
+            $clone_cfg;
+
+            #  Dependencies:
+            #
+            #  tex: depends: libbar(c)
+            #       depends: libfoo(c)
+            #
+            #  tix: depends: libbar(c)
+            #       depends: tex(c)
+            #
+            $* tex 2>!;
+
+            # Build new dependency of an existing dependent.
+            #
+            $* tix 2>>~%EOE%;
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add tix/1.0.0
+              trace: collect_build_prerequisites: begin tix/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tix/1.0.0
+              trace: postponed_configurations::add: create {tix | libbar->{tix/1,1}}
+              trace: collect_build_prerequisites: postpone tix/1.0.0
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {tix | libbar->{tix/1,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {tix | libbar->{tix/1,1}}
+              %.*
+              trace: collect_build: add tex/1.0.0
+              trace: collect_build_prerequisites: reeval tex/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {tex^ 1,1: libbar} to {tix | libbar->{tix/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent tex/1.0.0 results in {tex^ tix | libbar->{tex/1,1 tix/1,1}}
+              trace: collect_build_prerequisites: re-evaluated tex/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate begin {tex^ tix | libbar->{tex/1,1 tix/1,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libbar/1.0.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+              trace: collect_build_prerequisites: resume tex/1.0.0
+              %.*
+              trace: collect_build: add libfoo/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0
+              trace: postponed_configurations::add: create {tex | libfoo->{tex/2,1}}
+              trace: collect_build_prerequisites: postpone tex/1.0.0
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+              trace: collect_build_prerequisites: resume tix/1.0.0
+              %.*
+              trace: collect_build_prerequisites: cannot cfg-postpone dependency tex/1.0.0 of dependent tix/1.0.0 (collected prematurely), throwing postpone_dependency
+              trace: pkg_build: collection failed due to prematurely collected dependency (tex), retry from scratch
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add tix/1.0.0
+              trace: collect_build_prerequisites: begin tix/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tix/1.0.0
+              trace: postponed_configurations::add: create {tix | libbar->{tix/1,1}}
+              trace: collect_build_prerequisites: postpone tix/1.0.0
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {tix | libbar->{tix/1,1}}
+              %.*
+              trace: collect_build_postponed (1): skip dep-postponed existing dependent tex of dependency libbar
+              trace: collect_build_postponed (1): cfg-negotiate begin {tix | libbar->{tix/1,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libbar/1.0.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+              trace: collect_build_prerequisites: resume tix/1.0.0
+              %.*
+              trace: collect_build: add tex/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency tex/1.0.0 of dependent tix/1.0.0
+              trace: postponed_configurations::add: create {tix | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: postpone tix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate end {tix | libbar->{tix/1,1}}!
+              trace: collect_build_postponed (2): begin {tix | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (2): cfg-negotiate begin {tix | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin tex/1.0.0
+              %.*
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/1.0.0
+              trace: postponed_configurations::add: add {tex 1,1: libbar} to {tix | libbar->{tix/1,1}}!
+              trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tex/1.0.0 is negotiated
+              trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tex/1.0.0 is already (being) recursively collected, skipping
+              %.*
+              trace: collect_build: add libfoo/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/1.0.0
+              trace: postponed_configurations::add: create {tex | libfoo->{tex/2,1}}
+              trace: collect_build_prerequisites: postpone tex/1.0.0
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+              trace: collect_build_prerequisites: resume tix/1.0.0
+              trace: collect_build_prerequisites: end tix/1.0.0
+              trace: collect_build_postponed (2): cfg-negotiate end {tix | tex->{tix/2,1}}!
+              trace: collect_build_postponed (3): begin {tex | libfoo->{tex/2,1}}
+              %.*
+              trace: collect_build_postponed (3): skip being built existing dependent tex of dependency libfoo
+              trace: collect_build_postponed (3): cfg-negotiate begin {tex | libfoo->{tex/2,1}}
+              %.*
+              trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tex/1.0.0
+              trace: collect_build_prerequisites: resume tex/1.0.0
+              trace: collect_build_prerequisites: end tex/1.0.0
+              trace: collect_build_postponed (3): cfg-negotiate end {tex | libfoo->{tex/2,1}}!
+              trace: collect_build_postponed (3): end {tex | libfoo->{tex/2,1}}
+              trace: collect_build_postponed (2): end {tix | tex->{tix/2,1}}
+              trace: collect_build_postponed (1): end {tix | libbar->{tix/1,1}}
+              trace: collect_build_postponed (0): end
+              %.*
+              trace: execute_plan: simulate: yes
+              %.*
+              EOE
+
+            $pkg_status -r >>EOO;
+              !tex configured 1.0.0
+                libbar configured 1.0.0
+                libfoo configured 1.0.0
+              !tix configured 1.0.0
+                libbar configured 1.0.0
+                !tex configured 1.0.0
+                  libbar configured 1.0.0
+                  libfoo configured 1.0.0
+              EOO
+
+            # Downgrade the existing dependency of an existing dependent.
+            #
+            $* tex/0.3.0 2>>~%EOE%;
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add tex/0.3.0
+              %.*
+              trace: collect_build_prerequisites: cfg-postpone dependency tex/0.3.0 of existing dependent tix/1.0.0
+              trace: postponed_configurations::add: create {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build: add tix/1.0.0
+              trace: collect_build_prerequisites: reeval tix/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              %.*
+              trace: collect_build: pick tex/0.3.0 over tex/1.0.0
+              trace: postponed_configurations::add: add {tix^ 2,1: tex} to {tix^ | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent tix/1.0.0 results in {tix^ | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: re-evaluated tix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate begin {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin tex/0.3.0
+              %.*
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/0.3.0
+              trace: postponed_configurations::add: create {tex | libbar->{tex/1,1}}
+              trace: collect_build_prerequisites: postpone tex/0.3.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+              trace: collect_build_prerequisites: resume tix/1.0.0
+              trace: collect_build_prerequisites: end tix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate end {tix^ | tex->{tix/2,1}}!
+              trace: collect_build_postponed (2): begin {tex | libbar->{tex/1,1}}
+              %.*
+              trace: collect_build_postponed (2): skip being built existing dependent tex of dependency libbar
+              trace: collect_build_postponed (2): re-evaluate existing dependents for {tex | libbar->{tex/1,1}}
+              trace: collect_build_postponed (2): cannot re-evaluate dependent tix to dependency index 1 due to greater dependency index 2 in {tix^ | tex->{tix/2,1}}!, throwing postpone_position
+              trace: pkg_build: collection failed due to earlier dependency position, retry from scratch
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add tex/0.3.0
+              %.*
+              trace: collect_build_prerequisites: cfg-postpone dependency tex/0.3.0 of existing dependent tix/1.0.0
+              trace: postponed_configurations::add: create {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (1): pos-postpone existing dependent tix re-evaluation to dependency index 2 due to recorded index 1, skipping {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (0): postpone cfg-negotiation of {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (0): non-negotiated clusters left and non-replace postponed positions are present, overriding first encountered non-replace position to replace
+              trace: collect_build_postponed (1): begin {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (1): pos-postpone existing dependent tix re-evaluation to dependency index 2 due to recorded index 1, skipping {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (0): replace dependency at index 2 of existing dependent tix/1.0.0 with dependency libbar/1.0.0 at index 1
+              trace: collect_build: add libbar/1.0.0
+              trace: postponed_configurations::add: create {tix^ | libbar->{tix/1,1}}
+              trace: collect_build_postponed (0): postpone cfg-negotiation of {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (1): begin {tix^ | libbar->{tix/1,1}}
+              %.*
+              trace: collect_build_postponed (1): skip being built existing dependent tex of dependency libbar
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {tix^ | libbar->{tix/1,1}}
+              trace: collect_build: add tix/1.0.0
+              trace: collect_build_prerequisites: reeval tix/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {tix^ 1,1: libbar} to {tix^ | libbar->{tix/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent tix/1.0.0 results in {tix^ | libbar->{tix/1,1}}
+              trace: collect_build_prerequisites: re-evaluated tix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate begin {tix^ | libbar->{tix/1,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libbar/1.0.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+              trace: collect_build_prerequisites: resume tix/1.0.0
+              %.*
+              trace: collect_build: pick tex/0.3.0 over tex/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency tex/0.3.0 of dependent tix/1.0.0
+              trace: postponed_configurations::add: add {tix 2,1: tex} to {tix^ | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: postpone tix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate end {tix^ | libbar->{tix/1,1}}!
+              trace: collect_build_postponed (2): begin {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (2): skip being built existing dependent tix of dependency tex
+              trace: collect_build_postponed (2): cfg-negotiate begin {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin tex/0.3.0
+              %.*
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tex/0.3.0
+              trace: postponed_configurations::add: add {tex 1,1: libbar} to {tix^ | libbar->{tix/1,1}}!
+              trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent tex/0.3.0 is negotiated
+              trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent tex/0.3.0 is already (being) recursively collected, skipping
+              %.*
+              trace: collect_build: add libfoo/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/0.3.0
+              trace: postponed_configurations::add: create {tex | libfoo->{tex/2,1}}
+              trace: collect_build_prerequisites: postpone tex/0.3.0
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+              trace: collect_build_prerequisites: resume tix/1.0.0
+              trace: collect_build_prerequisites: end tix/1.0.0
+              trace: collect_build_postponed (2): cfg-negotiate end {tix^ | tex->{tix/2,1}}!
+              trace: collect_build_postponed (3): begin {tex | libfoo->{tex/2,1}}
+              %.*
+              trace: collect_build_postponed (3): skip being built existing dependent tex of dependency libfoo
+              trace: collect_build_postponed (3): cfg-negotiate begin {tex | libfoo->{tex/2,1}}
+              %.*
+              trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent tex/0.3.0
+              trace: collect_build_prerequisites: resume tex/0.3.0
+              trace: collect_build_prerequisites: end tex/0.3.0
+              trace: collect_build_postponed (3): cfg-negotiate end {tex | libfoo->{tex/2,1}}!
+              trace: collect_build_postponed (3): end {tex | libfoo->{tex/2,1}}
+              trace: collect_build_postponed (2): end {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (1): end {tix^ | libbar->{tix/1,1}}
+              trace: collect_build_postponed (0): end
+              %.*
+              trace: execute_plan: simulate: yes
+              %.*
+              EOE
+
+            $pkg_drop tex tix
+          }
+
+          : dependency-downgrade
+          :
+          : Note that here we also specify the existing dependent tix on the
+          : command line to make sure that its noop recursive collection
+          : doesn't prevent it from being properly re-evaluated afterwords.
+          :
+          : Also note that tex/0.1.0 doesn't depend on libbar.
+          {
+            $clone_cfg;
+
+            #  Dependencies:
+            #
+            #  tex: depends: libbar(c)
+            #       depends: libfoo(c)
+            #
+            #  tix: depends: libbar(c)
+            #       depends: tex(c)
+            #
+            $* tex tix 2>!;
+
+            $* tix tex/0.1.0 2>>~%EOE%;
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add tix/1.0.0
+              trace: collect_build: add tex/0.1.0
+              trace: collect_build_prerequisites: skip configured tix/1.0.0
+              %.*
+              trace: collect_build_prerequisites: cfg-postpone dependency tex/0.1.0 of existing dependent tix/1.0.0
+              trace: postponed_configurations::add: create {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {tix^ | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: reeval tix/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              %.*
+              trace: collect_build: pick tex/0.1.0 over tex/1.0.0
+              trace: postponed_configurations::add: add {tix^ 2,1: tex} to {tix^ | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent tix/1.0.0 results in {tix^ | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: re-evaluated tix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate begin {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin tex/0.1.0
+              %.*
+              trace: collect_build: add libfoo/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/0.1.0
+              trace: postponed_configurations::add: create {tex | libfoo->{tex/1,1}}
+              trace: collect_build_prerequisites: postpone tex/0.1.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+              trace: collect_build_prerequisites: resume tix/1.0.0
+              trace: collect_build_prerequisites: end tix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate end {tix^ | tex->{tix/2,1}}!
+              trace: collect_build_postponed (2): begin {tex | libfoo->{tex/1,1}}
+              %.*
+              trace: collect_build_postponed (2): skip being built existing dependent tex of dependency libfoo
+              trace: collect_build_postponed (2): cfg-negotiate begin {tex | libfoo->{tex/1,1}}
+              %.*
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tex/0.1.0
+              trace: collect_build_prerequisites: resume tex/0.1.0
+              trace: collect_build_prerequisites: end tex/0.1.0
+              trace: collect_build_postponed (2): cfg-negotiate end {tex | libfoo->{tex/1,1}}!
+              trace: collect_build_postponed (2): end {tex | libfoo->{tex/1,1}}
+              trace: collect_build_postponed (1): end {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (0): end
+              %.*
+              trace: execute_plan: simulate: yes
+              %.*
+              EOE
+
+            $pkg_drop tex tix
+          }
+
+          : dependency-downgrade-unhold
+          :
+          : As above but the dependency is also unheld.
+          :
+          {
+            $clone_cfg;
+
+            #  Dependencies:
+            #
+            #  tex: depends: libbar(c)
+            #       depends: libfoo(c)
+            #
+            #  tix: depends: libbar(c)
+            #       depends: tex(c)
+            #
+            $* tex tix 2>!;
+
+            $* tix ?tex/0.1.0 2>>~%EOE%;
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add tix/1.0.0
+              trace: collect_build_prerequisites: skip configured tix/1.0.0
+              trace: execute_plan: simulate: yes
+              %.*
+              trace: evaluate_dependency: tex/1.0.0: update to tex/0.1.0
+              %.*
+              trace: pkg_build: refine package collection/plan execution
+              %.*
+              trace: collect_build_prerequisites: cfg-postpone dependency tex/0.1.0 of existing dependent tix/1.0.0
+              trace: postponed_configurations::add: create {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {tix^ | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: reeval tix/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              %.*
+              trace: collect_build: pick tex/0.1.0 over tex/1.0.0
+              trace: postponed_configurations::add: add {tix^ 2,1: tex} to {tix^ | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent tix/1.0.0 results in {tix^ | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: re-evaluated tix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate begin {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin tex/0.1.0
+              %.*
+              trace: collect_build: add libfoo/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/0.1.0
+              trace: postponed_configurations::add: create {tex | libfoo->{tex/1,1}}
+              trace: collect_build_prerequisites: postpone tex/0.1.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+              trace: collect_build_prerequisites: resume tix/1.0.0
+              trace: collect_build_prerequisites: end tix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate end {tix^ | tex->{tix/2,1}}!
+              trace: collect_build_postponed (2): begin {tex | libfoo->{tex/1,1}}
+              %.*
+              trace: collect_build_postponed (2): skip being built existing dependent tex of dependency libfoo
+              trace: collect_build_postponed (2): cfg-negotiate begin {tex | libfoo->{tex/1,1}}
+              %.*
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tex/0.1.0
+              trace: collect_build_prerequisites: resume tex/0.1.0
+              trace: collect_build_prerequisites: end tex/0.1.0
+              trace: collect_build_postponed (2): cfg-negotiate end {tex | libfoo->{tex/1,1}}!
+              trace: collect_build_postponed (2): end {tex | libfoo->{tex/1,1}}
+              trace: collect_build_postponed (1): end {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (0): end
+              %.*
+              trace: execute_plan: simulate: yes
+              %.*
+              EOE
+
+            $pkg_drop tix
+          }
+
+          : dependency-downgrade-unhold-premature
+          :
+          : As above but the dependency (tex) depends on libbar without
+          : configuration clause.
+          :
+          {
+            $clone_cfg;
+
+            #  Dependencies:
+            #
+            #  tex: depends: libbar(c)
+            #       depends: libfoo(c)
+            #
+            #  tix: depends: libbar(c)
+            #       depends: tex(c)
+            #
+            $* tex tix 2>!;
+
+            $* tix ?tex/0.2.0 2>>~%EOE%;
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add tix/1.0.0
+              trace: collect_build_prerequisites: skip configured tix/1.0.0
+              trace: execute_plan: simulate: yes
+              %.*
+              trace: evaluate_dependency: tex/1.0.0: update to tex/0.2.0
+              %.*
+              trace: pkg_build: refine package collection/plan execution
+              %.*
+              trace: collect_build_prerequisites: cfg-postpone dependency tex/0.2.0 of existing dependent tix/1.0.0
+              trace: postponed_configurations::add: create {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {tix^ | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: reeval tix/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              %.*
+              trace: collect_build: pick tex/0.2.0 over tex/1.0.0
+              trace: postponed_configurations::add: add {tix^ 2,1: tex} to {tix^ | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent tix/1.0.0 results in {tix^ | tex->{tix/2,1}}
+              trace: collect_build_prerequisites: re-evaluated tix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate begin {tix^ | tex->{tix/2,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin tex/0.2.0
+              %.*
+              trace: collect_build_prerequisites: no cfg-clause for dependency libbar/1.0.0 of dependent tex/0.2.0
+              %.*
+              trace: collect_build: add libfoo/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent tex/0.2.0
+              trace: postponed_configurations::add: create {tex | libfoo->{tex/2,1}}
+              trace: collect_build_prerequisites: postpone tex/0.2.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tix/1.0.0
+              trace: collect_build_prerequisites: resume tix/1.0.0
+              trace: collect_build_prerequisites: end tix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate end {tix^ | tex->{tix/2,1}}!
+              trace: collect_build_postponed (2): begin {tex | libfoo->{tex/2,1}}
+              %.*
+              trace: collect_build_postponed (2): skip being built existing dependent tex of dependency libfoo
+              trace: collect_build_postponed (2): cfg-negotiate begin {tex | libfoo->{tex/2,1}}
+              %.*
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent tex/0.2.0
+              trace: collect_build_prerequisites: resume tex/0.2.0
+              trace: collect_build_prerequisites: end tex/0.2.0
+              trace: collect_build_postponed (2): cfg-negotiate end {tex | libfoo->{tex/2,1}}!
+              trace: collect_build_postponed (2): end {tex | libfoo->{tex/2,1}}
+              trace: collect_build_postponed (1): end {tix^ | tex->{tix/2,1}}
+              trace: collect_build_postponed (0): end
+              %.*
+              trace: execute_plan: simulate: yes
+              %.*
+              EOE
+
+            $pkg_drop tix
+          }
+        }
+      }
+
+      : indirect
+      :
+      {
+        +$clone_cfg
+
+        : args-tax-dex-dix
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  tax: depends: libbar(c)
+          #       depends: libfoo
+          #
+          #  bar: depends: libbar(c)
+          #
+          #  dex: depends: bar(c)
+          #       depends: libfoo(c)
+          #
+          #  dox: dex(c)
+          #
+          #  dix: depends: libbar(c)
+          #       depends: libbox(c) # causes postponment and initial cluster finished negotiating
+          #       depends: dox(c)
+          #
+          $* tax dex dix 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tax/1.0.0
+            trace: collect_build: add dex/1.0.0
+            trace: collect_build: add dix/1.0.0
+            trace: collect_build_prerequisites: begin tax/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tax/1.0.0
+            trace: postponed_configurations::add: create {tax | libbar->{tax/1,1}}
+            trace: collect_build_prerequisites: postpone tax/1.0.0
+            trace: collect_build_prerequisites: begin dex/1.0.0
+            %.*
+            trace: collect_build: add bar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | bar->{dex/1,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_prerequisites: begin dix/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent dix/1.0.0
+            trace: postponed_configurations::add: add {dix 1,1: libbar} to {tax | libbar->{tax/1,1}}
+            trace: collect_build_prerequisites: postpone dix/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {dix tax | libbar->{dix/1,1 tax/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {dix tax | libbar->{dix/1,1 tax/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+            trace: collect_build_prerequisites: resume dix/1.0.0
+            %.*
+            trace: collect_build: add libbox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent dix/1.0.0
+            trace: postponed_configurations::add: create {dix | libbox->{dix/2,1}}
+            trace: collect_build_prerequisites: postpone dix/1.0.0
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tax/1.0.0
+            trace: collect_build_prerequisites: resume tax/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent tax/1.0.0
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_prerequisites: end tax/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {dix tax | libbar->{dix/1,1 tax/1,1}}!
+            trace: collect_build_postponed (2): begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bar/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+            trace: postponed_configurations::add: add {bar 1,1: libbar} to {dix tax | libbar->{dix/1,1 tax/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bar/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bar/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end bar/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency libfoo/1.0.0 of dependent dex/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (libfoo), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tax/1.0.0
+            trace: collect_build: add dex/1.0.0
+            trace: collect_build: add dix/1.0.0
+            trace: collect_build_prerequisites: begin tax/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tax/1.0.0
+            trace: postponed_configurations::add: create {tax | libbar->{tax/1,1}}
+            trace: collect_build_prerequisites: postpone tax/1.0.0
+            trace: collect_build_prerequisites: begin dex/1.0.0
+            %.*
+            trace: collect_build: add bar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | bar->{dex/1,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_prerequisites: begin dix/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent dix/1.0.0
+            trace: postponed_configurations::add: add {dix 1,1: libbar} to {tax | libbar->{tax/1,1}}
+            trace: collect_build_prerequisites: postpone dix/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {dix tax | libbar->{dix/1,1 tax/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {dix tax | libbar->{dix/1,1 tax/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+            trace: collect_build_prerequisites: resume dix/1.0.0
+            %.*
+            trace: collect_build: add libbox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent dix/1.0.0
+            trace: postponed_configurations::add: create {dix | libbox->{dix/2,1}}
+            trace: collect_build_prerequisites: postpone dix/1.0.0
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tax/1.0.0
+            trace: collect_build_prerequisites: resume tax/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent tax/1.0.0
+            trace: collect_build_prerequisites: end tax/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {dix tax | libbar->{dix/1,1 tax/1,1}}!
+            trace: collect_build_postponed (2): begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bar/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+            trace: postponed_configurations::add: add {bar 1,1: libbar} to {dix tax | libbar->{dix/1,1 tax/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bar/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bar/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end bar/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | libfoo->{dex/2,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {dex | bar->{dex/1,1}}!
+            trace: collect_build_postponed (3): begin {dix | libbox->{dix/2,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {dix | libbox->{dix/2,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbox/1.0.0
+            trace: collect_build_prerequisites: end libbox/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+            trace: collect_build_prerequisites: resume dix/1.0.0
+            %.*
+            trace: collect_build: add dox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency dox/1.0.0 of dependent dix/1.0.0
+            trace: postponed_configurations::add: create {dix | dox->{dix/3,1}}
+            trace: collect_build_prerequisites: postpone dix/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {dix | libbox->{dix/2,1}}!
+            trace: collect_build_postponed (4): begin {dex | libfoo->{dex/2,1}}
+            %.*
+            trace: collect_build_postponed (4): cfg-negotiate begin {dex | libfoo->{dex/2,1}}
+            %.*
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            trace: collect_build_prerequisites: end dex/1.0.0
+            trace: collect_build_postponed (4): cfg-negotiate end {dex | libfoo->{dex/2,1}}!
+            trace: collect_build_postponed (5): begin {dix | dox->{dix/3,1}}
+            %.*
+            trace: collect_build_postponed (5): cfg-negotiate begin {dix | dox->{dix/3,1}}
+            %.*
+            trace: collect_build_postponed (5): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin dox/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency dex/1.0.0 of dependent dox/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (dex), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tax/1.0.0
+            trace: collect_build: add dex/1.0.0
+            trace: collect_build: add dix/1.0.0
+            trace: collect_build_prerequisites: begin tax/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tax/1.0.0
+            trace: postponed_configurations::add: create {tax | libbar->{tax/1,1}}
+            trace: collect_build_prerequisites: postpone tax/1.0.0
+            trace: pkg_build: dep-postpone user-specified dex
+            trace: collect_build_prerequisites: begin dix/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent dix/1.0.0
+            trace: postponed_configurations::add: add {dix 1,1: libbar} to {tax | libbar->{tax/1,1}}
+            trace: collect_build_prerequisites: postpone dix/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {dix tax | libbar->{dix/1,1 tax/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {dix tax | libbar->{dix/1,1 tax/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+            trace: collect_build_prerequisites: resume dix/1.0.0
+            %.*
+            trace: collect_build: add libbox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent dix/1.0.0
+            trace: postponed_configurations::add: create {dix | libbox->{dix/2,1}}
+            trace: collect_build_prerequisites: postpone dix/1.0.0
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tax/1.0.0
+            trace: collect_build_prerequisites: resume tax/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent tax/1.0.0
+            trace: collect_build_prerequisites: end tax/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {dix tax | libbar->{dix/1,1 tax/1,1}}!
+            trace: collect_build_postponed (2): begin {dix | libbox->{dix/2,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {dix | libbox->{dix/2,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbox/1.0.0
+            trace: collect_build_prerequisites: end libbox/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+            trace: collect_build_prerequisites: resume dix/1.0.0
+            %.*
+            trace: collect_build: add dox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency dox/1.0.0 of dependent dix/1.0.0
+            trace: postponed_configurations::add: create {dix | dox->{dix/3,1}}
+            trace: collect_build_prerequisites: postpone dix/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {dix | libbox->{dix/2,1}}!
+            trace: collect_build_postponed (3): begin {dix | dox->{dix/3,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {dix | dox->{dix/3,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin dox/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency dex/1.0.0 of dependent dox/1.0.0
+            trace: postponed_configurations::add: create {dox | dex->{dox/1,1}}
+            trace: collect_build_prerequisites: postpone dox/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+            trace: collect_build_prerequisites: resume dix/1.0.0
+            trace: collect_build_prerequisites: end dix/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {dix | dox->{dix/3,1}}!
+            trace: collect_build_postponed (4): begin {dox | dex->{dox/1,1}}
+            %.*
+            trace: collect_build_postponed (4): cfg-negotiate begin {dox | dex->{dox/1,1}}
+            %.*
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin dex/1.0.0
+            %.*
+            trace: collect_build: add bar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | bar->{dex/1,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent dox/1.0.0
+            trace: collect_build_prerequisites: resume dox/1.0.0
+            trace: collect_build_prerequisites: end dox/1.0.0
+            trace: collect_build_postponed (4): cfg-negotiate end {dox | dex->{dox/1,1}}!
+            trace: collect_build_postponed (5): begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (5): cfg-negotiate begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (5): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bar/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+            trace: postponed_configurations::add: add {bar 1,1: libbar} to {dix tax | libbar->{dix/1,1 tax/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bar/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bar/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end bar/1.0.0
+            trace: collect_build_postponed (5): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (5): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | libfoo->{dex/2,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_postponed (5): cfg-negotiate end {dex | bar->{dex/1,1}}!
+            trace: collect_build_postponed (6): begin {dex | libfoo->{dex/2,1}}
+            %.*
+            trace: collect_build_postponed (6): cfg-negotiate begin {dex | libfoo->{dex/2,1}}
+            trace: collect_build_postponed (6): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (6): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (6): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            trace: collect_build_prerequisites: end dex/1.0.0
+            trace: collect_build_postponed (6): cfg-negotiate end {dex | libfoo->{dex/2,1}}!
+            trace: collect_build_postponed (6): end {dex | libfoo->{dex/2,1}}
+            trace: collect_build_postponed (5): end {dex | bar->{dex/1,1}}
+            trace: collect_build_postponed (4): end {dox | dex->{dox/1,1}}
+            trace: collect_build_postponed (3): end {dix | dox->{dix/3,1}}
+            trace: collect_build_postponed (2): end {dix | libbox->{dix/2,1}}
+            trace: collect_build_postponed (1): end {dix tax | libbar->{dix/1,1 tax/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !tax configured 1.0.0
+              libbar configured 1.0.0
+              libfoo configured 1.0.0
+            !dex configured 1.0.0
+              bar configured 1.0.0
+                libbar configured 1.0.0
+              libfoo configured 1.0.0
+            !dix configured 1.0.0
+              dox configured 1.0.0
+                !dex configured 1.0.0
+                  bar configured 1.0.0
+                    libbar configured 1.0.0
+                  libfoo configured 1.0.0
+              libbar configured 1.0.0
+              libbox configured 1.0.0
+            EOO
+
+          $pkg_drop tax dex dix --drop-dependent
+        }
+
+        : args-dix
+        :
+        : As above but with the different command-line arguments which results
+        : in the different cluster list at the moment of the cycle detection.
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  bar: depends: libbar(c)
+          #
+          #  dex: depends: bar(c)
+          #       depends: libfoo(c)
+          #
+          #  dox: dex(c)
+          #
+          #  dix: depends: libbar(c)
+          #       depends: libbox(c) # causes postponment and initial cluster finished negotiating
+          #       depends: dox(c)
+          #
+          $* dix 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add dix/1.0.0
+            trace: collect_build_prerequisites: begin dix/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent dix/1.0.0
+            trace: postponed_configurations::add: create {dix | libbar->{dix/1,1}}
+            trace: collect_build_prerequisites: postpone dix/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {dix | libbar->{dix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {dix | libbar->{dix/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+            trace: collect_build_prerequisites: resume dix/1.0.0
+            %.*
+            trace: collect_build: add libbox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent dix/1.0.0
+            trace: postponed_configurations::add: create {dix | libbox->{dix/2,1}}
+            trace: collect_build_prerequisites: postpone dix/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {dix | libbar->{dix/1,1}}!
+            trace: collect_build_postponed (2): begin {dix | libbox->{dix/2,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {dix | libbox->{dix/2,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbox/1.0.0
+            trace: collect_build_prerequisites: end libbox/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+            trace: collect_build_prerequisites: resume dix/1.0.0
+            %.*
+            trace: collect_build: add dox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency dox/1.0.0 of dependent dix/1.0.0
+            trace: postponed_configurations::add: create {dix | dox->{dix/3,1}}
+            trace: collect_build_prerequisites: postpone dix/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {dix | libbox->{dix/2,1}}!
+            trace: collect_build_postponed (3): begin {dix | dox->{dix/3,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {dix | dox->{dix/3,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin dox/1.0.0
+            %.*
+            trace: collect_build: add dex/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency dex/1.0.0 of dependent dox/1.0.0
+            trace: postponed_configurations::add: create {dox | dex->{dox/1,1}}
+            trace: collect_build_prerequisites: postpone dox/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+            trace: collect_build_prerequisites: resume dix/1.0.0
+            trace: collect_build_prerequisites: end dix/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {dix | dox->{dix/3,1}}!
+            trace: collect_build_postponed (4): begin {dox | dex->{dox/1,1}}
+            %.*
+            trace: collect_build_postponed (4): cfg-negotiate begin {dox | dex->{dox/1,1}}
+            %.*
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin dex/1.0.0
+            %.*
+            trace: collect_build: add bar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | bar->{dex/1,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent dox/1.0.0
+            trace: collect_build_prerequisites: resume dox/1.0.0
+            trace: collect_build_prerequisites: end dox/1.0.0
+            trace: collect_build_postponed (4): cfg-negotiate end {dox | dex->{dox/1,1}}!
+            trace: collect_build_postponed (5): begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (5): cfg-negotiate begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (5): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bar/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+            trace: postponed_configurations::add: add {bar 1,1: libbar} to {dix | libbar->{dix/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bar/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bar/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end bar/1.0.0
+            trace: collect_build_postponed (5): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (5): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | libfoo->{dex/2,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_postponed (5): cfg-negotiate end {dex | bar->{dex/1,1}}!
+            trace: collect_build_postponed (6): begin {dex | libfoo->{dex/2,1}}
+            %.*
+            trace: collect_build_postponed (6): cfg-negotiate begin {dex | libfoo->{dex/2,1}}
+            %.*
+            trace: collect_build_postponed (6): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (6): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (6): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            trace: collect_build_prerequisites: end dex/1.0.0
+            trace: collect_build_postponed (6): cfg-negotiate end {dex | libfoo->{dex/2,1}}!
+            trace: collect_build_postponed (6): end {dex | libfoo->{dex/2,1}}
+            trace: collect_build_postponed (5): end {dex | bar->{dex/1,1}}
+            trace: collect_build_postponed (4): end {dox | dex->{dox/1,1}}
+            trace: collect_build_postponed (3): end {dix | dox->{dix/3,1}}
+            trace: collect_build_postponed (2): end {dix | libbox->{dix/2,1}}
+            trace: collect_build_postponed (1): end {dix | libbar->{dix/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !dix configured 1.0.0
+              dox configured 1.0.0
+                dex configured 1.0.0
+                  bar configured 1.0.0
+                    libbar configured 1.0.0
+                  libfoo configured 1.0.0
+              libbar configured 1.0.0
+              libbox configured 1.0.0
+            EOO
+
+          $pkg_drop dix
+        }
+
+        : args-tax-dex-diz
+        :
+        : Note that diz is a correct version of dix, which fixes the
+        : configuration cycle.
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  tax: depends: libbar(c)
+          #       depends: libfoo
+          #
+          #  bar: depends: libbar(c)
+          #
+          #  dex: depends: bar(c)
+          #       depends: libfoo(c)
+          #
+          #  dox: dex(c)
+          #
+          #  diz: depends: dox(c)
+          #       depends: libbox(c)
+          #       depends: libbar(c)
+          #
+          $* tax dex diz 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tax/1.0.0
+            trace: collect_build: add dex/1.0.0
+            trace: collect_build: add diz/1.0.0
+            trace: collect_build_prerequisites: begin tax/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tax/1.0.0
+            trace: postponed_configurations::add: create {tax | libbar->{tax/1,1}}
+            trace: collect_build_prerequisites: postpone tax/1.0.0
+            trace: collect_build_prerequisites: begin dex/1.0.0
+            %.*
+            trace: collect_build: add bar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | bar->{dex/1,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_prerequisites: begin diz/1.0.0
+            %.*
+            trace: collect_build: add dox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency dox/1.0.0 of dependent diz/1.0.0
+            trace: postponed_configurations::add: create {diz | dox->{diz/1,1}}
+            trace: collect_build_prerequisites: postpone diz/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tax | libbar->{tax/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tax | libbar->{tax/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tax/1.0.0
+            trace: collect_build_prerequisites: resume tax/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: no cfg-clause for dependency libfoo/1.0.0 of dependent tax/1.0.0
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_prerequisites: end tax/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tax | libbar->{tax/1,1}}!
+            trace: collect_build_postponed (2): begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bar/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+            trace: postponed_configurations::add: add {bar 1,1: libbar} to {tax | libbar->{tax/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bar/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bar/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end bar/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency libfoo/1.0.0 of dependent dex/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (libfoo), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tax/1.0.0
+            trace: collect_build: add dex/1.0.0
+            trace: collect_build: add diz/1.0.0
+            trace: collect_build_prerequisites: begin tax/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tax/1.0.0
+            trace: postponed_configurations::add: create {tax | libbar->{tax/1,1}}
+            trace: collect_build_prerequisites: postpone tax/1.0.0
+            trace: collect_build_prerequisites: begin dex/1.0.0
+            %.*
+            trace: collect_build: add bar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | bar->{dex/1,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_prerequisites: begin diz/1.0.0
+            %.*
+            trace: collect_build: add dox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency dox/1.0.0 of dependent diz/1.0.0
+            trace: postponed_configurations::add: create {diz | dox->{diz/1,1}}
+            trace: collect_build_prerequisites: postpone diz/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tax | libbar->{tax/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tax | libbar->{tax/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tax/1.0.0
+            trace: collect_build_prerequisites: resume tax/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent tax/1.0.0
+            trace: collect_build_prerequisites: end tax/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tax | libbar->{tax/1,1}}!
+            trace: collect_build_postponed (2): begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bar/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+            trace: postponed_configurations::add: add {bar 1,1: libbar} to {tax | libbar->{tax/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bar/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bar/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end bar/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | libfoo->{dex/2,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {dex | bar->{dex/1,1}}!
+            trace: collect_build_postponed (3): begin {diz | dox->{diz/1,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {diz | dox->{diz/1,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin dox/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency dex/1.0.0 of dependent dox/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (dex), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add tax/1.0.0
+            trace: collect_build: add dex/1.0.0
+            trace: collect_build: add diz/1.0.0
+            trace: collect_build_prerequisites: begin tax/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent tax/1.0.0
+            trace: postponed_configurations::add: create {tax | libbar->{tax/1,1}}
+            trace: collect_build_prerequisites: postpone tax/1.0.0
+            trace: pkg_build: dep-postpone user-specified dex
+            trace: collect_build_prerequisites: begin diz/1.0.0
+            %.*
+            trace: collect_build: add dox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency dox/1.0.0 of dependent diz/1.0.0
+            trace: postponed_configurations::add: create {diz | dox->{diz/1,1}}
+            trace: collect_build_prerequisites: postpone diz/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {tax | libbar->{tax/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {tax | libbar->{tax/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent tax/1.0.0
+            trace: collect_build_prerequisites: resume tax/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: dep-postpone dependency libfoo/1.0.0 of dependent tax/1.0.0
+            trace: collect_build_prerequisites: end tax/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {tax | libbar->{tax/1,1}}!
+            trace: collect_build_postponed (2): begin {diz | dox->{diz/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {diz | dox->{diz/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin dox/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency dex/1.0.0 of dependent dox/1.0.0
+            trace: postponed_configurations::add: create {dox | dex->{dox/1,1}}
+            trace: collect_build_prerequisites: postpone dox/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent diz/1.0.0
+            trace: collect_build_prerequisites: resume diz/1.0.0
+            %.*
+            trace: collect_build: add libbox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent diz/1.0.0
+            trace: postponed_configurations::add: create {diz | libbox->{diz/2,1}}
+            trace: collect_build_prerequisites: postpone diz/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {diz | dox->{diz/1,1}}!
+            trace: collect_build_postponed (3): begin {dox | dex->{dox/1,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {dox | dex->{dox/1,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin dex/1.0.0
+            %.*
+            trace: collect_build: add bar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | bar->{dex/1,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent dox/1.0.0
+            trace: collect_build_prerequisites: resume dox/1.0.0
+            trace: collect_build_prerequisites: end dox/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {dox | dex->{dox/1,1}}!
+            trace: collect_build_postponed (4): begin {diz | libbox->{diz/2,1}}
+            %.*
+            trace: collect_build_postponed (4): cfg-negotiate begin {diz | libbox->{diz/2,1}}
+            %.*
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbox/1.0.0
+            trace: collect_build_prerequisites: end libbox/1.0.0
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent diz/1.0.0
+            trace: collect_build_prerequisites: resume diz/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent diz/1.0.0
+            trace: postponed_configurations::add: add {diz 3,1: libbar} to {tax | libbar->{tax/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent diz/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent diz/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end diz/1.0.0
+            trace: collect_build_postponed (4): cfg-negotiate end {diz | libbox->{diz/2,1}}!
+            trace: collect_build_postponed (5): begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (5): cfg-negotiate begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (5): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bar/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+            trace: postponed_configurations::add: add {bar 1,1: libbar} to {diz tax | libbar->{diz/3,1 tax/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bar/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bar/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end bar/1.0.0
+            trace: collect_build_postponed (5): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (5): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | libfoo->{dex/2,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_postponed (5): cfg-negotiate end {dex | bar->{dex/1,1}}!
+            trace: collect_build_postponed (6): begin {dex | libfoo->{dex/2,1}}
+            %.*
+            trace: collect_build_postponed (6): cfg-negotiate begin {dex | libfoo->{dex/2,1}}
+            %.*
+            trace: collect_build_postponed (6): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (6): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (6): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            trace: collect_build_prerequisites: end dex/1.0.0
+            trace: collect_build_postponed (6): cfg-negotiate end {dex | libfoo->{dex/2,1}}!
+            trace: collect_build_postponed (6): end {dex | libfoo->{dex/2,1}}
+            trace: collect_build_postponed (5): end {dex | bar->{dex/1,1}}
+            trace: collect_build_postponed (4): end {diz | libbox->{diz/2,1}}
+            trace: collect_build_postponed (3): end {dox | dex->{dox/1,1}}
+            trace: collect_build_postponed (2): end {diz | dox->{diz/1,1}}
+            trace: collect_build_postponed (1): end {tax | libbar->{tax/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !tax configured 1.0.0
+              libbar configured 1.0.0
+              libfoo configured 1.0.0
+            !dex configured 1.0.0
+              bar configured 1.0.0
+                libbar configured 1.0.0
+              libfoo configured 1.0.0
+            !diz configured 1.0.0
+              dox configured 1.0.0
+                !dex configured 1.0.0
+                  bar configured 1.0.0
+                    libbar configured 1.0.0
+                  libfoo configured 1.0.0
+              libbar configured 1.0.0
+              libbox configured 1.0.0
+            EOO
+
+          $pkg_drop tax dex diz --drop-dependent
+        }
+
+        : args-diz
+        :
+        : Note that diz is a correct version of dix, which fixes the
+        : configuration cycle.
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  bar: depends: libbar(c)
+          #
+          #  dex: depends: bar(c)
+          #       depends: libfoo(c)
+          #
+          #  dox: dex(c)
+          #
+          #  diz: depends: dox(c)
+          #       depends: libbox(c)
+          #       depends: libbar(c)
+          #
+          $* diz 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add diz/1.0.0
+            trace: collect_build_prerequisites: begin diz/1.0.0
+            %.*
+            trace: collect_build: add dox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency dox/1.0.0 of dependent diz/1.0.0
+            trace: postponed_configurations::add: create {diz | dox->{diz/1,1}}
+            trace: collect_build_prerequisites: postpone diz/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {diz | dox->{diz/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {diz | dox->{diz/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin dox/1.0.0
+            %.*
+            trace: collect_build: add dex/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency dex/1.0.0 of dependent dox/1.0.0
+            trace: postponed_configurations::add: create {dox | dex->{dox/1,1}}
+            trace: collect_build_prerequisites: postpone dox/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent diz/1.0.0
+            trace: collect_build_prerequisites: resume diz/1.0.0
+            %.*
+            trace: collect_build: add libbox/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent diz/1.0.0
+            trace: postponed_configurations::add: create {diz | libbox->{diz/2,1}}
+            trace: collect_build_prerequisites: postpone diz/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {diz | dox->{diz/1,1}}!
+            trace: collect_build_postponed (2): begin {dox | dex->{dox/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {dox | dex->{dox/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin dex/1.0.0
+            %.*
+            trace: collect_build: add bar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | bar->{dex/1,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent dox/1.0.0
+            trace: collect_build_prerequisites: resume dox/1.0.0
+            trace: collect_build_prerequisites: end dox/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {dox | dex->{dox/1,1}}!
+            trace: collect_build_postponed (3): begin {diz | libbox->{diz/2,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {diz | libbox->{diz/2,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbox/1.0.0
+            trace: collect_build_prerequisites: end libbox/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent diz/1.0.0
+            trace: collect_build_prerequisites: resume diz/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent diz/1.0.0
+            trace: postponed_configurations::add: create {diz | libbar->{diz/3,1}}
+            trace: collect_build_prerequisites: postpone diz/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {diz | libbox->{diz/2,1}}!
+            trace: collect_build_postponed (4): begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (4): cfg-negotiate begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bar/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+            trace: postponed_configurations::add: add {bar 1,1: libbar} to {diz | libbar->{diz/3,1}}
+            trace: collect_build_prerequisites: postpone bar/1.0.0
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | libfoo->{dex/2,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_postponed (4): cfg-negotiate end {dex | bar->{dex/1,1}}!
+            trace: collect_build_postponed (5): begin {bar diz | libbar->{bar/1,1 diz/3,1}}
+            %.*
+            trace: collect_build_postponed (5): cfg-negotiate begin {bar diz | libbar->{bar/1,1 diz/3,1}}
+            %.*
+            trace: collect_build_postponed (5): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (5): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (5): select cfg-negotiated dependency alternative for dependent bar/1.0.0
+            trace: collect_build_prerequisites: resume bar/1.0.0
+            trace: collect_build_prerequisites: end bar/1.0.0
+            trace: collect_build_postponed (5): select cfg-negotiated dependency alternative for dependent diz/1.0.0
+            trace: collect_build_prerequisites: resume diz/1.0.0
+            trace: collect_build_prerequisites: end diz/1.0.0
+            trace: collect_build_postponed (5): cfg-negotiate end {bar diz | libbar->{bar/1,1 diz/3,1}}!
+            trace: collect_build_postponed (6): begin {dex | libfoo->{dex/2,1}}
+            %.*
+            trace: collect_build_postponed (6): cfg-negotiate begin {dex | libfoo->{dex/2,1}}
+            %.*
+            trace: collect_build_postponed (6): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (6): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (6): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            trace: collect_build_prerequisites: end dex/1.0.0
+            trace: collect_build_postponed (6): cfg-negotiate end {dex | libfoo->{dex/2,1}}!
+            trace: collect_build_postponed (6): end {dex | libfoo->{dex/2,1}}
+            trace: collect_build_postponed (5): end {bar diz | libbar->{bar/1,1 diz/3,1}}
+            trace: collect_build_postponed (4): end {dex | bar->{dex/1,1}}
+            trace: collect_build_postponed (3): end {diz | libbox->{diz/2,1}}
+            trace: collect_build_postponed (2): end {dox | dex->{dox/1,1}}
+            trace: collect_build_postponed (1): end {diz | dox->{diz/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !diz configured 1.0.0
+              dox configured 1.0.0
+                dex configured 1.0.0
+                  bar configured 1.0.0
+                    libbar configured 1.0.0
+                  libfoo configured 1.0.0
+              libbar configured 1.0.0
+              libbox configured 1.0.0
+            EOO
+
+          $pkg_drop diz
+        }
+
+        : depends-depends-conflict
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  bar: depends: libbar(c)
+          #
+          #  dex: depends: bar(c)
+          #       depends: libfoo(c)
+          #
+          #  bux: depends: libbar(c)
+          #
+          #  buc: depends: libfoo(c)
+          #       depends: bux(c)
+          #
+          $* bar dex buc bux 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add bar/1.0.0
+            trace: collect_build: add dex/1.0.0
+            trace: collect_build: add buc/1.0.0
+            trace: collect_build: add bux/1.0.0
+            trace: collect_build_prerequisites: begin bar/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+            trace: postponed_configurations::add: create {bar | libbar->{bar/1,1}}
+            trace: collect_build_prerequisites: postpone bar/1.0.0
+            trace: collect_build_prerequisites: begin dex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (bar), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add bar/1.0.0
+            trace: collect_build: add dex/1.0.0
+            trace: collect_build: add buc/1.0.0
+            trace: collect_build: add bux/1.0.0
+            trace: pkg_build: dep-postpone user-specified bar
+            trace: collect_build_prerequisites: begin dex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | bar->{dex/1,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_prerequisites: begin buc/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent buc/1.0.0
+            trace: postponed_configurations::add: create {buc | libfoo->{buc/1,1}}
+            trace: collect_build_prerequisites: postpone buc/1.0.0
+            trace: collect_build_prerequisites: begin bux/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bux/1.0.0
+            trace: postponed_configurations::add: create {bux | libbar->{bux/1,1}}
+            trace: collect_build_prerequisites: postpone bux/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bar/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+            trace: postponed_configurations::add: add {bar 1,1: libbar} to {bux | libbar->{bux/1,1}}
+            trace: collect_build_prerequisites: postpone bar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: add {dex 2,1: libfoo} to {buc | libfoo->{buc/1,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {dex | bar->{dex/1,1}}!
+            trace: collect_build_postponed (2): begin {buc dex | libfoo->{buc/1,1 dex/2,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {buc dex | libfoo->{buc/1,1 dex/2,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent buc/1.0.0
+            trace: collect_build_prerequisites: resume buc/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency bux/1.0.0 of dependent buc/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (bux), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add bar/1.0.0
+            trace: collect_build: add dex/1.0.0
+            trace: collect_build: add buc/1.0.0
+            trace: collect_build: add bux/1.0.0
+            trace: collect_build_prerequisites: begin bar/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+            trace: postponed_configurations::add: create {bar | libbar->{bar/1,1}}
+            trace: collect_build_prerequisites: postpone bar/1.0.0
+            trace: collect_build_prerequisites: begin dex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (bar), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add bar/1.0.0
+            trace: collect_build: add dex/1.0.0
+            trace: collect_build: add buc/1.0.0
+            trace: collect_build: add bux/1.0.0
+            trace: pkg_build: dep-postpone user-specified bar
+            trace: collect_build_prerequisites: begin dex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: create {dex | bar->{dex/1,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_prerequisites: begin buc/1.0.0
+            %.*
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent buc/1.0.0
+            trace: postponed_configurations::add: create {buc | libfoo->{buc/1,1}}
+            trace: collect_build_prerequisites: postpone buc/1.0.0
+            trace: pkg_build: dep-postpone user-specified bux
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {dex | bar->{dex/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bar/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+            trace: postponed_configurations::add: create {bar | libbar->{bar/1,1}}
+            trace: collect_build_prerequisites: postpone bar/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent dex/1.0.0
+            trace: postponed_configurations::add: add {dex 2,1: libfoo} to {buc | libfoo->{buc/1,1}}
+            trace: collect_build_prerequisites: postpone dex/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {dex | bar->{dex/1,1}}!
+            trace: collect_build_postponed (2): begin {buc dex | libfoo->{buc/1,1 dex/2,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {buc dex | libfoo->{buc/1,1 dex/2,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent buc/1.0.0
+            trace: collect_build_prerequisites: resume buc/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency bux/1.0.0 of dependent buc/1.0.0
+            trace: postponed_configurations::add: create {buc | bux->{buc/2,1}}
+            trace: collect_build_prerequisites: postpone buc/1.0.0
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+            trace: collect_build_prerequisites: resume dex/1.0.0
+            trace: collect_build_prerequisites: end dex/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {buc dex | libfoo->{buc/1,1 dex/2,1}}!
+            trace: collect_build_postponed (3): begin {bar | libbar->{bar/1,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {bar | libbar->{bar/1,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bar/1.0.0
+            trace: collect_build_prerequisites: resume bar/1.0.0
+            trace: collect_build_prerequisites: end bar/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {bar | libbar->{bar/1,1}}!
+            trace: collect_build_postponed (4): begin {buc | bux->{buc/2,1}}
+            %.*
+            trace: collect_build_postponed (4): cfg-negotiate begin {buc | bux->{buc/2,1}}
+            %.*
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bux/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bux/1.0.0
+            trace: postponed_configurations::add: add {bux 1,1: libbar} to {bar | libbar->{bar/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bux/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bux/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end bux/1.0.0
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent buc/1.0.0
+            trace: collect_build_prerequisites: resume buc/1.0.0
+            trace: collect_build_prerequisites: end buc/1.0.0
+            trace: collect_build_postponed (4): cfg-negotiate end {buc | bux->{buc/2,1}}!
+            trace: collect_build_postponed (4): end {buc | bux->{buc/2,1}}
+            trace: collect_build_postponed (3): end {bar | libbar->{bar/1,1}}
+            trace: collect_build_postponed (2): end {buc dex | libfoo->{buc/1,1 dex/2,1}}
+            trace: collect_build_postponed (1): end {dex | bar->{dex/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !bar configured 1.0.0
+              libbar configured 1.0.0
+            !dex configured 1.0.0
+              !bar configured 1.0.0
+                libbar configured 1.0.0
+              libfoo configured 1.0.0
+            !bux configured 1.0.0
+              libbar configured 1.0.0
+            !buc configured 1.0.0
+              !bux configured 1.0.0
+                libbar configured 1.0.0
+              libfoo configured 1.0.0
+            EOO
+
+          $pkg_drop bar dex buc bux
+        }
+
+        : package-depends-conflict
+        :
+        {
+          $clone_cfg;
+
+          #  Dependencies:
+          #
+          #  baz: depends: {libbar libfoo} (c)
+          #
+          #  bas: depends: libbar(c)
+          #       depends: bus (c)
+          #
+          #  bus: depends: libbaz(c)
+          #       depends: foo (c)
+          #
+          #  foo: depends: libfoo(c)
+          #
+          #  bat: depends: libbaz(c)
+          #
+          $* baz bas bus foo bat 2>>~%EOE%;
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add baz/1.0.0
+            trace: collect_build: add bas/1.0.0
+            trace: collect_build: add bus/1.0.0
+            trace: collect_build: add foo/1.0.0
+            trace: collect_build: add bat/1.0.0
+            trace: collect_build_prerequisites: begin baz/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent baz/1.0.0
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent baz/1.0.0
+            trace: postponed_configurations::add: create {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: postpone baz/1.0.0
+            trace: collect_build_prerequisites: begin bas/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bas/1.0.0
+            trace: postponed_configurations::add: add {bas 1,1: libbar} to {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: postpone bas/1.0.0
+            trace: collect_build_prerequisites: begin bus/1.0.0
+            %.*
+            trace: collect_build: add libbaz/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbaz/1.0.0 of dependent bus/1.0.0
+            trace: postponed_configurations::add: create {bus | libbaz->{bus/1,1}}
+            trace: collect_build_prerequisites: postpone bus/1.0.0
+            trace: collect_build_prerequisites: begin foo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+            trace: postponed_configurations::add: add {foo 1,1: libfoo} to {bas baz | libbar->{bas/1,1 baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: postpone foo/1.0.0
+            trace: collect_build_prerequisites: begin bat/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbaz/1.0.0 of dependent bat/1.0.0
+            trace: postponed_configurations::add: add {bat 1,1: libbaz} to {bus | libbaz->{bus/1,1}}
+            trace: collect_build_prerequisites: postpone bat/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {bas baz foo | libbar->{bas/1,1 baz/1,1} libfoo->{baz/1,1 foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {bas baz foo | libbar->{bas/1,1 baz/1,1} libfoo->{baz/1,1 foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bas/1.0.0
+            trace: collect_build_prerequisites: resume bas/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency bus/1.0.0 of dependent bas/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (bus), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add baz/1.0.0
+            trace: collect_build: add bas/1.0.0
+            trace: collect_build: add bus/1.0.0
+            trace: collect_build: add foo/1.0.0
+            trace: collect_build: add bat/1.0.0
+            trace: collect_build_prerequisites: begin baz/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent baz/1.0.0
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent baz/1.0.0
+            trace: postponed_configurations::add: create {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: postpone baz/1.0.0
+            trace: collect_build_prerequisites: begin bas/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bas/1.0.0
+            trace: postponed_configurations::add: add {bas 1,1: libbar} to {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: postpone bas/1.0.0
+            trace: pkg_build: dep-postpone user-specified bus
+            trace: collect_build_prerequisites: begin foo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+            trace: postponed_configurations::add: add {foo 1,1: libfoo} to {bas baz | libbar->{bas/1,1 baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: postpone foo/1.0.0
+            trace: collect_build_prerequisites: begin bat/1.0.0
+            %.*
+            trace: collect_build: add libbaz/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbaz/1.0.0 of dependent bat/1.0.0
+            trace: postponed_configurations::add: create {bat | libbaz->{bat/1,1}}
+            trace: collect_build_prerequisites: postpone bat/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {bas baz foo | libbar->{bas/1,1 baz/1,1} libfoo->{baz/1,1 foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {bas baz foo | libbar->{bas/1,1 baz/1,1} libfoo->{baz/1,1 foo/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bas/1.0.0
+            trace: collect_build_prerequisites: resume bas/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency bus/1.0.0 of dependent bas/1.0.0
+            trace: postponed_configurations::add: create {bas | bus->{bas/2,1}}
+            trace: collect_build_prerequisites: postpone bas/1.0.0
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent baz/1.0.0
+            trace: collect_build_prerequisites: resume baz/1.0.0
+            trace: collect_build_prerequisites: end baz/1.0.0
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent foo/1.0.0
+            trace: collect_build_prerequisites: resume foo/1.0.0
+            trace: collect_build_prerequisites: end foo/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {bas baz foo | libbar->{bas/1,1 baz/1,1} libfoo->{baz/1,1 foo/1,1}}!
+            trace: collect_build_postponed (2): begin {bat | libbaz->{bat/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {bat | libbaz->{bat/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbaz/1.0.0
+            trace: collect_build_prerequisites: end libbaz/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bat/1.0.0
+            trace: collect_build_prerequisites: resume bat/1.0.0
+            trace: collect_build_prerequisites: end bat/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {bat | libbaz->{bat/1,1}}!
+            trace: collect_build_postponed (3): begin {bas | bus->{bas/2,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {bas | bus->{bas/2,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bus/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbaz/1.0.0 of dependent bus/1.0.0
+            trace: postponed_configurations::add: add {bus 1,1: libbaz} to {bat | libbaz->{bat/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bus/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbaz/1.0.0 of dependent bus/1.0.0 is already (being) recursively collected, skipping
+            %.*
+            trace: collect_build_prerequisites: cannot cfg-postpone dependency foo/1.0.0 of dependent bus/1.0.0 (collected prematurely), throwing postpone_dependency
+            trace: pkg_build: collection failed due to prematurely collected dependency (foo), retry from scratch
+            %.*
+            trace: pkg_build: refine package collection/plan execution from scratch
+            %.*
+            trace: collect_build: add baz/1.0.0
+            trace: collect_build: add bas/1.0.0
+            trace: collect_build: add bus/1.0.0
+            trace: collect_build: add foo/1.0.0
+            trace: collect_build: add bat/1.0.0
+            trace: collect_build_prerequisites: begin baz/1.0.0
+            %.*
+            trace: collect_build: add libbar/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent baz/1.0.0
+            trace: collect_build: add libfoo/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent baz/1.0.0
+            trace: postponed_configurations::add: create {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: postpone baz/1.0.0
+            trace: collect_build_prerequisites: begin bas/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bas/1.0.0
+            trace: postponed_configurations::add: add {bas 1,1: libbar} to {baz | libbar->{baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_prerequisites: postpone bas/1.0.0
+            trace: pkg_build: dep-postpone user-specified bus
+            trace: pkg_build: dep-postpone user-specified foo
+            trace: collect_build_prerequisites: begin bat/1.0.0
+            %.*
+            trace: collect_build: add libbaz/1.0.0
+            trace: collect_build_prerequisites: cfg-postpone dependency libbaz/1.0.0 of dependent bat/1.0.0
+            trace: postponed_configurations::add: create {bat | libbaz->{bat/1,1}}
+            trace: collect_build_prerequisites: postpone bat/1.0.0
+            trace: collect_build_postponed (0): begin
+            trace: collect_build_postponed (1): begin {bas baz | libbar->{bas/1,1 baz/1,1} libfoo->{baz/1,1}}
+            %.*
+            trace: collect_build_postponed (1): cfg-negotiate begin {bas baz | libbar->{bas/1,1 baz/1,1} libfoo->{baz/1,1}}
+            %.*
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbar/1.0.0
+            trace: collect_build_prerequisites: end libbar/1.0.0
+            trace: collect_build_prerequisites: begin libfoo/1.0.0
+            trace: collect_build_prerequisites: end libfoo/1.0.0
+            trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bas/1.0.0
+            trace: collect_build_prerequisites: resume bas/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency bus/1.0.0 of dependent bas/1.0.0
+            trace: postponed_configurations::add: create {bas | bus->{bas/2,1}}
+            trace: collect_build_prerequisites: postpone bas/1.0.0
+            trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent baz/1.0.0
+            trace: collect_build_prerequisites: resume baz/1.0.0
+            trace: collect_build_prerequisites: end baz/1.0.0
+            trace: collect_build_postponed (1): cfg-negotiate end {bas baz | libbar->{bas/1,1 baz/1,1} libfoo->{baz/1,1}}!
+            trace: collect_build_postponed (2): begin {bat | libbaz->{bat/1,1}}
+            %.*
+            trace: collect_build_postponed (2): cfg-negotiate begin {bat | libbaz->{bat/1,1}}
+            %.*
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin libbaz/1.0.0
+            trace: collect_build_prerequisites: end libbaz/1.0.0
+            trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent bat/1.0.0
+            trace: collect_build_prerequisites: resume bat/1.0.0
+            trace: collect_build_prerequisites: end bat/1.0.0
+            trace: collect_build_postponed (2): cfg-negotiate end {bat | libbaz->{bat/1,1}}!
+            trace: collect_build_postponed (3): begin {bas | bus->{bas/2,1}}
+            %.*
+            trace: collect_build_postponed (3): cfg-negotiate begin {bas | bus->{bas/2,1}}
+            %.*
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin bus/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libbaz/1.0.0 of dependent bus/1.0.0
+            trace: postponed_configurations::add: add {bus 1,1: libbaz} to {bat | libbaz->{bat/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bus/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libbaz/1.0.0 of dependent bus/1.0.0 is already (being) recursively collected, skipping
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency foo/1.0.0 of dependent bus/1.0.0
+            trace: postponed_configurations::add: create {bus | foo->{bus/2,1}}
+            trace: collect_build_prerequisites: postpone bus/1.0.0
+            trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent bas/1.0.0
+            trace: collect_build_prerequisites: resume bas/1.0.0
+            trace: collect_build_prerequisites: end bas/1.0.0
+            trace: collect_build_postponed (3): cfg-negotiate end {bas | bus->{bas/2,1}}!
+            trace: collect_build_postponed (4): begin {bus | foo->{bus/2,1}}
+            %.*
+            trace: collect_build_postponed (4): cfg-negotiate begin {bus | foo->{bus/2,1}}
+            %.*
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies
+            trace: collect_build_prerequisites: begin foo/1.0.0
+            %.*
+            trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent foo/1.0.0
+            trace: postponed_configurations::add: add {foo 1,1: libfoo} to {bas baz | libbar->{bas/1,1 baz/1,1} libfoo->{baz/1,1}}!
+            trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent foo/1.0.0 is negotiated
+            trace: collect_build_prerequisites: dependency libfoo/1.0.0 of dependent foo/1.0.0 is already (being) recursively collected, skipping
+            trace: collect_build_prerequisites: end foo/1.0.0
+            trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents
+            trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent bus/1.0.0
+            trace: collect_build_prerequisites: resume bus/1.0.0
+            trace: collect_build_prerequisites: end bus/1.0.0
+            trace: collect_build_postponed (4): cfg-negotiate end {bus | foo->{bus/2,1}}!
+            trace: collect_build_postponed (4): end {bus | foo->{bus/2,1}}
+            trace: collect_build_postponed (3): end {bas | bus->{bas/2,1}}
+            trace: collect_build_postponed (2): end {bat | libbaz->{bat/1,1}}
+            trace: collect_build_postponed (1): end {bas baz | libbar->{bas/1,1 baz/1,1} libfoo->{baz/1,1}}
+            trace: collect_build_postponed (0): end
+            trace: execute_plan: simulate: yes
+            %.*
+            EOE
+
+          $pkg_status -r >>EOO;
+            !baz configured 1.0.0
+              libbar configured 1.0.0
+              libfoo configured 1.0.0
+            !foo configured 1.0.0
+              libfoo configured 1.0.0
+            !bus configured 1.0.0
+              !foo configured 1.0.0
+                libfoo configured 1.0.0
+              libbaz configured 1.0.0
+            !bas configured 1.0.0
+              !bus configured 1.0.0
+                !foo configured 1.0.0
+                  libfoo configured 1.0.0
+                libbaz configured 1.0.0
+              libbar configured 1.0.0
+            !bat configured 1.0.0
+              libbaz configured 1.0.0
+            EOO
+
+          $pkg_drop baz bas bus foo bat
+        }
+
+        : existing
+        :
+        {
+          +$clone_cfg
+
+          : negotiate
+          :
+          {
+            $clone_cfg;
+
+            #  Dependencies:
+            #
+            #  bar: depends: libbar(c)
+            #
+            #  dex: depends: bar(c)
+            #       depends: libfoo(c)
+            #
+            #  dox: dex(c)
+            #
+            #  dix: depends: libbar(c)
+            #       depends: libbox(c) # causes postponment and initial cluster finished negotiating
+            #       depends: dox(c)
+            #
+            $* dex 2>!;
+
+            $* dix 2>>~%EOE%;
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add dix/1.0.0
+              trace: collect_build_prerequisites: begin dix/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent dix/1.0.0
+              trace: postponed_configurations::add: create {dix | libbar->{dix/1,1}}
+              trace: collect_build_prerequisites: postpone dix/1.0.0
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {dix | libbar->{dix/1,1}}
+              %.*
+              trace: collect_build_postponed (1): re-evaluate existing dependents for {dix | libbar->{dix/1,1}}
+              %.*
+              trace: collect_build: add bar/1.0.0
+              trace: collect_build_prerequisites: reeval bar/1.0.0
+              %.*
+              trace: postponed_configurations::add: add {bar^ 1,1: libbar} to {dix | libbar->{dix/1,1}}
+              trace: collect_build_prerequisites: re-evaluating dependent bar/1.0.0 results in {bar^ dix | libbar->{bar/1,1 dix/1,1}}
+              trace: collect_build_prerequisites: re-evaluated bar/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate begin {bar^ dix | libbar->{bar/1,1 dix/1,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libbar/1.0.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent bar/1.0.0
+              trace: collect_build_prerequisites: resume bar/1.0.0
+              trace: collect_build_prerequisites: end bar/1.0.0
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+              trace: collect_build_prerequisites: resume dix/1.0.0
+              %.*
+              trace: collect_build: add libbox/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent dix/1.0.0
+              trace: postponed_configurations::add: create {dix | libbox->{dix/2,1}}
+              trace: collect_build_prerequisites: postpone dix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate end {bar^ dix | libbar->{bar/1,1 dix/1,1}}!
+              trace: collect_build_postponed (2): begin {dix | libbox->{dix/2,1}}
+              %.*
+              trace: collect_build_postponed (2): cfg-negotiate begin {dix | libbox->{dix/2,1}}
+              %.*
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin libbox/1.0.0
+              trace: collect_build_prerequisites: end libbox/1.0.0
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+              trace: collect_build_prerequisites: resume dix/1.0.0
+              %.*
+              trace: collect_build: add dox/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency dox/1.0.0 of dependent dix/1.0.0
+              trace: postponed_configurations::add: create {dix | dox->{dix/3,1}}
+              trace: collect_build_prerequisites: postpone dix/1.0.0
+              trace: collect_build_postponed (2): cfg-negotiate end {dix | libbox->{dix/2,1}}!
+              trace: collect_build_postponed (3): begin {dix | dox->{dix/3,1}}
+              %.*
+              trace: collect_build_postponed (3): cfg-negotiate begin {dix | dox->{dix/3,1}}
+              %.*
+              trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin dox/1.0.0
+              %.*
+              trace: collect_build: add dex/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency dex/1.0.0 of dependent dox/1.0.0
+              trace: postponed_configurations::add: create {dox | dex->{dox/1,1}}
+              trace: collect_build_prerequisites: postpone dox/1.0.0
+              trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+              trace: collect_build_prerequisites: resume dix/1.0.0
+              trace: collect_build_prerequisites: end dix/1.0.0
+              trace: collect_build_postponed (3): cfg-negotiate end {dix | dox->{dix/3,1}}!
+              trace: collect_build_postponed (4): begin {dox | dex->{dox/1,1}}
+              %.*
+              trace: collect_build_postponed (4): cfg-negotiate begin {dox | dex->{dox/1,1}}
+              %.*
+              trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin dex/1.0.0
+              %.*
+              trace: collect_build_prerequisites: cannot cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0 (collected prematurely), throwing postpone_dependency
+              trace: pkg_build: collection failed due to prematurely collected dependency (bar), retry from scratch
+              %.*
+              trace: pkg_build: refine package collection/plan execution from scratch
+              %.*
+              trace: collect_build: add dix/1.0.0
+              trace: collect_build_prerequisites: begin dix/1.0.0
+              %.*
+              trace: collect_build: add libbar/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent dix/1.0.0
+              trace: postponed_configurations::add: create {dix | libbar->{dix/1,1}}
+              trace: collect_build_prerequisites: postpone dix/1.0.0
+              trace: collect_build_postponed (0): begin
+              trace: collect_build_postponed (1): begin {dix | libbar->{dix/1,1}}
+              %.*
+              trace: collect_build_postponed (1): skip dep-postponed existing dependent bar of dependency libbar
+              trace: collect_build_postponed (1): cfg-negotiate begin {dix | libbar->{dix/1,1}}
+              %.*
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libbar/1.0.0
+              trace: collect_build_postponed (1): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (1): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+              trace: collect_build_prerequisites: resume dix/1.0.0
+              %.*
+              trace: collect_build: add libbox/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libbox/1.0.0 of dependent dix/1.0.0
+              trace: postponed_configurations::add: create {dix | libbox->{dix/2,1}}
+              trace: collect_build_prerequisites: postpone dix/1.0.0
+              trace: collect_build_postponed (1): cfg-negotiate end {dix | libbar->{dix/1,1}}!
+              trace: collect_build_postponed (2): begin {dix | libbox->{dix/2,1}}
+              %.*
+              trace: collect_build_postponed (2): cfg-negotiate begin {dix | libbox->{dix/2,1}}
+              %.*
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin libbox/1.0.0
+              trace: collect_build_prerequisites: end libbox/1.0.0
+              trace: collect_build_postponed (2): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (2): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+              trace: collect_build_prerequisites: resume dix/1.0.0
+              %.*
+              trace: collect_build: add dox/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency dox/1.0.0 of dependent dix/1.0.0
+              trace: postponed_configurations::add: create {dix | dox->{dix/3,1}}
+              trace: collect_build_prerequisites: postpone dix/1.0.0
+              trace: collect_build_postponed (2): cfg-negotiate end {dix | libbox->{dix/2,1}}!
+              trace: collect_build_postponed (3): begin {dix | dox->{dix/3,1}}
+              %.*
+              trace: collect_build_postponed (3): cfg-negotiate begin {dix | dox->{dix/3,1}}
+              %.*
+              trace: collect_build_postponed (3): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin dox/1.0.0
+              %.*
+              trace: collect_build: add dex/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency dex/1.0.0 of dependent dox/1.0.0
+              trace: postponed_configurations::add: create {dox | dex->{dox/1,1}}
+              trace: collect_build_prerequisites: postpone dox/1.0.0
+              trace: collect_build_postponed (3): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (3): select cfg-negotiated dependency alternative for dependent dix/1.0.0
+              trace: collect_build_prerequisites: resume dix/1.0.0
+              trace: collect_build_prerequisites: end dix/1.0.0
+              trace: collect_build_postponed (3): cfg-negotiate end {dix | dox->{dix/3,1}}!
+              trace: collect_build_postponed (4): begin {dox | dex->{dox/1,1}}
+              %.*
+              trace: collect_build_postponed (4): cfg-negotiate begin {dox | dex->{dox/1,1}}
+              %.*
+              trace: collect_build_postponed (4): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin dex/1.0.0
+              %.*
+              trace: collect_build: add bar/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency bar/1.0.0 of dependent dex/1.0.0
+              trace: postponed_configurations::add: create {dex | bar->{dex/1,1}}
+              trace: collect_build_prerequisites: postpone dex/1.0.0
+              trace: collect_build_postponed (4): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (4): select cfg-negotiated dependency alternative for dependent dox/1.0.0
+              trace: collect_build_prerequisites: resume dox/1.0.0
+              trace: collect_build_prerequisites: end dox/1.0.0
+              trace: collect_build_postponed (4): cfg-negotiate end {dox | dex->{dox/1,1}}!
+              trace: collect_build_postponed (5): begin {dex | bar->{dex/1,1}}
+              %.*
+              trace: collect_build_postponed (5): skip being built existing dependent dex of dependency bar
+              trace: collect_build_postponed (5): cfg-negotiate begin {dex | bar->{dex/1,1}}
+              %.*
+              trace: collect_build_postponed (5): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: begin bar/1.0.0
+              %.*
+              trace: collect_build_prerequisites: cfg-postpone dependency libbar/1.0.0 of dependent bar/1.0.0
+              trace: postponed_configurations::add: add {bar 1,1: libbar} to {dix | libbar->{dix/1,1}}!
+              trace: collect_build_prerequisites: configuration for cfg-postponed dependencies of dependent bar/1.0.0 is negotiated
+              trace: collect_build_prerequisites: dependency libbar/1.0.0 of dependent bar/1.0.0 is already (being) recursively collected, skipping
+              trace: collect_build_prerequisites: end bar/1.0.0
+              trace: collect_build_postponed (5): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (5): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+              trace: collect_build_prerequisites: resume dex/1.0.0
+              %.*
+              trace: collect_build: add libfoo/1.0.0
+              trace: collect_build_prerequisites: cfg-postpone dependency libfoo/1.0.0 of dependent dex/1.0.0
+              trace: postponed_configurations::add: create {dex | libfoo->{dex/2,1}}
+              trace: collect_build_prerequisites: postpone dex/1.0.0
+              trace: collect_build_postponed (5): cfg-negotiate end {dex | bar->{dex/1,1}}!
+              trace: collect_build_postponed (6): begin {dex | libfoo->{dex/2,1}}
+              %.*
+              trace: collect_build_postponed (6): skip being built existing dependent dex of dependency libfoo
+              trace: collect_build_postponed (6): cfg-negotiate begin {dex | libfoo->{dex/2,1}}
+              %.*
+              trace: collect_build_postponed (6): recursively collect cfg-negotiated dependencies
+              trace: collect_build_prerequisites: skip configured libfoo/1.0.0
+              trace: collect_build_postponed (6): recursively collect cfg-negotiated dependents
+              trace: collect_build_postponed (6): select cfg-negotiated dependency alternative for dependent dex/1.0.0
+              trace: collect_build_prerequisites: resume dex/1.0.0
+              trace: collect_build_prerequisites: end dex/1.0.0
+              trace: collect_build_postponed (6): cfg-negotiate end {dex | libfoo->{dex/2,1}}!
+              trace: collect_build_postponed (6): end {dex | libfoo->{dex/2,1}}
+              trace: collect_build_postponed (5): end {dex | bar->{dex/1,1}}
+              trace: collect_build_postponed (4): end {dox | dex->{dox/1,1}}
+              trace: collect_build_postponed (3): end {dix | dox->{dix/3,1}}
+              trace: collect_build_postponed (2): end {dix | libbox->{dix/2,1}}
+              trace: collect_build_postponed (1): end {dix | libbar->{dix/1,1}}
+              trace: collect_build_postponed (0): end
+              %.*
+              trace: execute_plan: simulate: yes
+              %.*
+              EOE
+
+            $pkg_status -r >>EOO;
+              !dex configured 1.0.0
+                bar configured 1.0.0
+                  libbar configured 1.0.0
+                libfoo configured 1.0.0
+              !dix configured 1.0.0
+                dox configured 1.0.0
+                  !dex configured 1.0.0
+                    bar configured 1.0.0
+                      libbar configured 1.0.0
+                    libfoo configured 1.0.0
+                libbar configured 1.0.0
+                libbox configured 1.0.0
+              EOO
+
+            # @@ Note that if --drop-dependent is unspecified, the following
+            #    command fails with:
+            #
+            #    following dependent packages will have to be dropped as well:
+            #      dox (requires dex)
+            #    error: refusing to drop dependent packages with just --yes
+            #      info: specify --drop-dependent to confirm
+            #
+            #    Feels wrong.
+            #
+            $pkg_drop --drop-dependent dex dix
+          }
+        }
+      }
+    }
+
+    : all-repo-packages
+    :
+    : Don't match the tracing but just make sure that pkg-build doesn't crash
+    : or hang and ends up with an expected packages setup.
+    :
+    {
+      $clone_cfg;
+
+      $* libfoo libbar ?libbaz/0.1.0 ?libbox/0.1.0 \
+         foo fox fux fix fex bar baz bac bat bas bus \
+         box bax bux bix bex boo biz buz buc tax tex \
+         tix tiz toz tez tux dex dix diz dox 2>!;
+
+      $pkg_status -r >>EOO;
+        !libfoo configured 1.0.0
+        !libbar configured 1.0.0
+        !bat configured 1.0.0
+          libbaz configured !0.1.0 available 1.0.0
+        !tix configured 0.1.0 available 1.0.0
+        !toz configured 0.1.0 available 1.0.0 0.2.0
+        !tux configured 1.0.0
+          libbox configured !0.1.0 available 1.0.0
+          !tix configured 0.1.0 available 1.0.0
+        !bar configured 1.0.0
+          !libbar configured 1.0.0
+        !bux configured 1.0.0
+          !libbar configured 1.0.0
+        !bex configured 1.0.0
+          !libbar configured 1.0.0
+        !boo configured 1.0.0
+          !libbar configured 1.0.0
+        !biz configured 1.0.0
+          !boo configured 1.0.0
+            !libbar configured 1.0.0
+        !buz configured 1.0.0
+          !bux configured 1.0.0
+            !libbar configured 1.0.0
+        !tez configured 1.0.0
+          !libbar configured 1.0.0
+          libbox configured !0.1.0 available 1.0.0
+          !toz configured 0.1.0 available 1.0.0 0.2.0
+        !bix configured 1.0.0
+          !bar configured 1.0.0
+            !libbar configured 1.0.0
+          !bux configured 1.0.0
+            !libbar configured 1.0.0
+          !libbar configured 1.0.0
+        !foo configured 1.0.0
+          !libfoo configured 1.0.0
+        !fox configured 1.0.0
+          !libfoo configured 1.0.0
+        !fux configured 1.0.0
+          !libfoo configured 1.0.0
+        !baz configured 1.0.0
+          !libbar configured 1.0.0
+          !libfoo configured 1.0.0
+        !bac configured 1.0.0
+          !libbar configured 1.0.0
+          libbaz configured !0.1.0 available 1.0.0
+          !libfoo configured 1.0.0
+        !fix configured 1.0.0
+          !foo configured 1.0.0
+            !libfoo configured 1.0.0
+        !fex configured 1.0.0
+          !foo configured 1.0.0
+            !libfoo configured 1.0.0
+          !libfoo configured 1.0.0
+        !bus configured 1.0.0
+          !foo configured 1.0.0
+            !libfoo configured 1.0.0
+          libbaz configured !0.1.0 available 1.0.0
+        !bas configured 1.0.0
+          !bus configured 1.0.0
+            !foo configured 1.0.0
+              !libfoo configured 1.0.0
+            libbaz configured !0.1.0 available 1.0.0
+          !libbar configured 1.0.0
+        !box configured 1.0.0
+          !libbar configured 1.0.0
+          !libfoo configured 1.0.0
+        !bax configured 1.0.0
+          !libbar configured 1.0.0
+          libbox configured !0.1.0 available 1.0.0
+          !libfoo configured 1.0.0
+        !buc configured 1.0.0
+          !bux configured 1.0.0
+            !libbar configured 1.0.0
+          !libfoo configured 1.0.0
+        !tax configured 1.0.0
+          !libbar configured 1.0.0
+          !libfoo configured 1.0.0
+        !tex configured 1.0.0
+          !libbar configured 1.0.0
+          !libfoo configured 1.0.0
+        !tiz configured 1.0.0
+          !libbar configured 1.0.0
+          !tex configured 1.0.0
+            !libbar configured 1.0.0
+            !libfoo configured 1.0.0
+        !dex configured 1.0.0
+          !bar configured 1.0.0
+            !libbar configured 1.0.0
+          !libfoo configured 1.0.0
+        !dox configured 1.0.0
+          !dex configured 1.0.0
+            !bar configured 1.0.0
+              !libbar configured 1.0.0
+            !libfoo configured 1.0.0
+        !dix configured 1.0.0
+          !dox configured 1.0.0
+            !dex configured 1.0.0
+              !bar configured 1.0.0
+                !libbar configured 1.0.0
+              !libfoo configured 1.0.0
+          !libbar configured 1.0.0
+          libbox configured !0.1.0 available 1.0.0
+        !diz configured 1.0.0
+          !dox configured 1.0.0
+            !dex configured 1.0.0
+              !bar configured 1.0.0
+                !libbar configured 1.0.0
+              !libfoo configured 1.0.0
+          !libbar configured 1.0.0
+          libbox configured !0.1.0 available 1.0.0
+        EOO
+
+      $pkg_drop libfoo libbar foo fox fux fix fex bar \
+                baz bac bat bas bus box bax bux bix bex \
+                boo biz buz buc tax tex tix tiz toz tez \
+                tux dex dix diz dox
+    }
+  }
+
+  : configuration-negotiation
+  :
+  {
+    test.arguments += --yes --plan 'build plan:'
+
+    : proj-better-choice
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13a && $rep_fetch
+
+      : bar
+      :
+      {
+        $clone_cfg;
+
+        $* bar 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar)
+              config.liba.backend=cli (set by bar)
+            new bar/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          %info: .+bar.+ is up to date%
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.backend = cli
+          EOO
+
+        $pkg_drop bar
+      }
+
+      : baz
+      :
+      {
+        $clone_cfg;
+
+        $* baz 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by baz)
+              config.liba.backend=gui (set by baz)
+            new baz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          configured liba/1.0.0
+          configured baz/1.0.0
+          %info: .+baz.+ is up to date%
+          updated baz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !baz configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.backend = gui
+          EOO
+
+        $pkg_drop baz
+      }
+
+      : bar-baz
+      :
+      {
+        $clone_cfg;
+
+        $* bar baz 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar, baz)
+              config.liba.backend=cli (set by bar)
+            new bar/1.0.0
+            new baz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          configured baz/1.0.0
+          %info: .+bar.+ is up to date%
+          %info: .+baz.+ is up to date%
+          updated bar/1.0.0
+          updated baz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          !baz configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.backend = cli
+          EOO
+
+        $pkg_drop bar baz
+      }
+
+      : baz-bar
+      :
+      {
+        $clone_cfg;
+
+        $* baz bar 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar, baz)
+              config.liba.backend=cli (set by bar)
+            new baz/1.0.0
+            new bar/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured baz/1.0.0
+          configured bar/1.0.0
+          %info: .+baz.+ is up to date%
+          %info: .+bar.+ is up to date%
+          updated baz/1.0.0
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !baz configured 1.0.0
+            liba configured 1.0.0
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        # Would have been cool to end up with gui but looks like we have a map
+        # in configuration cluster.
+        #
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.backend = cli
+          EOO
+
+        $pkg_drop baz bar
+      }
+
+      : bar-baz-biz
+      :
+      {
+        $clone_cfg;
+
+        $* bar baz biz 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar, baz, biz)
+              config.liba.backend=gui (set by biz)
+            new bar/1.0.0
+            new baz/1.0.0
+            new biz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          fetched biz/1.0.0
+          unpacked biz/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          configured baz/1.0.0
+          configured biz/1.0.0
+          %info: .+bar.+ is up to date%
+          %info: .+baz.+ is up to date%
+          %info: .+biz.+ is up to date%
+          updated bar/1.0.0
+          updated baz/1.0.0
+          updated biz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          !baz configured 1.0.0
+            liba configured 1.0.0
+          !biz configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.backend = gui
+          EOO
+
+        $pkg_drop bar baz biz
+      }
+    }
+
+    : proj-better-value
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13b && $rep_fetch
+
+      : liba
+      :
+      {
+        $clone_cfg;
+
+        $* liba 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          configured liba/1.0.0
+          %info: .+liba.+ is up to date%
+          updated liba/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = false
+          config.liba.buffer = 1024
+          EOO
+
+        $pkg_drop liba
+      }
+
+      : bar
+      :
+      {
+        $clone_cfg;
+
+        $* bar 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar)
+              config.liba.buffer=2048 (set by bar)
+            new bar/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          %info: .+bar.+ is up to date%
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = false
+          config.liba.buffer = 2048
+          EOO
+
+        $pkg_drop bar
+      }
+
+      : bar-liba
+      :
+      {
+        $clone_cfg;
+
+        $* bar ?liba +{ config.liba.x=true } 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0
+              config.liba.x=true (user configuration)
+              config.liba.buffer=10240 (set by bar)
+            new bar/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          %info: .+liba.+ is up to date%
+          %info: .+bar.+ is up to date%
+          updated liba/1.0.0
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          config.liba.buffer = 10240
+          EOO
+
+        $pkg_drop bar
+      }
+
+      : baz
+      :
+      {
+        $clone_cfg;
+
+        $* baz 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by baz)
+              config.liba.buffer=4096 (set by baz)
+            new baz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          configured liba/1.0.0
+          configured baz/1.0.0
+          %info: .+baz.+ is up to date%
+          updated baz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !baz configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = false
+          config.liba.buffer = 4096
+          EOO
+
+        $pkg_drop baz
+      }
+
+      : baz-liba
+      :
+      {
+        $clone_cfg;
+
+        $* baz ?liba +{ config.liba.x=true } 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0
+              config.liba.x=true (user configuration)
+              config.liba.buffer=10240 (set by baz)
+            new baz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          configured liba/1.0.0
+          configured baz/1.0.0
+          %info: .+liba.+ is up to date%
+          %info: .+baz.+ is up to date%
+          updated liba/1.0.0
+          updated baz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !baz configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          config.liba.buffer = 10240
+          EOO
+
+        $pkg_drop baz
+      }
+
+      : baz-biz
+      :
+      {
+        $clone_cfg;
+
+        $* baz biz 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by baz, biz)
+          %(
+              config.liba.buffer=10240 (set by baz)
+              config.liba.x=true (set by biz)
+          %|
+              config.liba.x=true (set by biz)
+              config.liba.buffer=10240 (set by baz)
+          %)
+            new baz/1.0.0
+            new biz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          fetched biz/1.0.0
+          unpacked biz/1.0.0
+          configured liba/1.0.0
+          configured baz/1.0.0
+          configured biz/1.0.0
+          %info: .+baz.+ is up to date%
+          %info: .+biz.+ is up to date%
+          updated baz/1.0.0
+          updated biz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !baz configured 1.0.0
+            liba configured 1.0.0
+          !biz configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          config.liba.buffer = 10240
+          EOO
+
+        $pkg_drop baz biz
+      }
+    }
+
+    : proj-disable-unused
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13c && $rep_fetch
+
+      : liba
+      :
+      {
+        $clone_cfg;
+
+        $* liba 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          configured liba/1.0.0
+          %info: .+liba.+ is up to date%
+          updated liba/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          EOO
+
+        $pkg_drop liba
+      }
+
+      : bar
+      :
+      {
+        $clone_cfg;
+
+        $* bar 2>>~%EOE%;
+          <depends-reflect-clause>:1:5: info: false
+            info: reflect clause:
+              info $config.liba.x
+            info: in depends manifest value of package bar
+          build plan:
+            new liba/1.0.0 (required by bar)
+              config.liba.x=false (set by bar)
+            new bar/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          %info: .+bar.+ is up to date%
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = false
+          EOO
+
+        $pkg_drop bar
+      }
+
+      : bar-baz
+      :
+      {
+        $clone_cfg;
+
+        $* bar baz 2>>~%EOE%;
+          <depends-reflect-clause>:1:5: info: true
+            info: reflect clause:
+              info $config.liba.x
+            info: in depends manifest value of package bar
+          build plan:
+            new liba/1.0.0 (required by bar, baz)
+              config.liba.x=true (set by baz)
+            new bar/1.0.0
+            new baz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          configured baz/1.0.0
+          %info: .+bar.+ is up to date%
+          %info: .+baz.+ is up to date%
+          updated bar/1.0.0
+          updated baz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          !baz configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          EOO
+
+        $pkg_drop bar baz
+      }
+
+      : bar-liba
+      :
+      {
+        $clone_cfg;
+
+        $* bar ?liba +{ config.liba.x=true } 2>>~%EOE%;
+          <depends-reflect-clause>:1:5: info: true
+            info: reflect clause:
+              info $config.liba.x
+            info: in depends manifest value of package bar
+          build plan:
+            new liba/1.0.0
+              config.liba.x=true (user configuration)
+            new bar/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          %info: .+liba.+ is up to date%
+          %info: .+bar.+ is up to date%
+          updated liba/1.0.0
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          EOO
+
+        $pkg_drop bar
+      }
+    }
+
+    : proj-use-if-available
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13d && $rep_fetch
+
+      : baz
+      :
+      {
+        $clone_cfg;
+
+        $* baz 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar, baz)
+              config.liba.x=true (set by baz)
+            new bar/1.0.0 (required by baz)
+              config.bar.liba_x=true (set by bar)
+            new baz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          configured baz/1.0.0
+          %info: .+baz.+ is up to date%
+          updated baz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !baz configured 1.0.0
+            bar configured 1.0.0
+              liba configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          EOO
+
+        $pkg_drop baz
+      }
+
+      : bar
+      :
+      {
+        $clone_cfg;
+
+        $* bar 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar)
+            new libb/1.0.0 (required by bar)
+            new bar/1.0.0
+              config.bar.liba_x=false (set by bar)
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched libb/1.0.0
+          unpacked libb/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured libb/1.0.0
+          configured bar/1.0.0
+          %info: .+bar.+ is up to date%
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+            libb configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = false
+          EOO
+
+        $pkg_drop bar
+      }
+    }
+
+    : proj-bogus-config
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13e && $rep_fetch
+
+      : baz
+      :
+      {
+        $clone_cfg;
+
+        $* baz 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by baz, biz)
+              config.liba.x=true (set by biz)
+            new biz/1.0.0 (required by baz)
+            new baz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched biz/1.0.0
+          unpacked biz/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          configured liba/1.0.0
+          configured biz/1.0.0
+          configured baz/1.0.0
+          %info: .+baz.+ is up to date%
+          updated baz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !baz configured 1.0.0
+            biz configured 1.0.0
+              liba configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          config.liba.buffer = 1024
+          EOO
+
+        $pkg_drop baz
+      }
+    }
+
+    : proj-bogus-config-cycle
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13f && $rep_fetch
+
+      : baz
+      :
+      {
+        $clone_cfg;
+
+        $* baz 2>>~%EOE% != 0;
+          error: unable to remove bogus configuration values without causing configuration refinement cycle
+            info: consider manually specifying one or more of the following variables as user configuration
+          %(
+              config.liba.buffer=2048
+              config.liba.x=true
+          %|
+              config.liba.x=true
+              config.liba.buffer=2048
+          %)
+          EOE
+
+        $* baz ?liba +{ config.liba.x=true } 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0
+              config.liba.x=true (user configuration)
+            new baz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          configured liba/1.0.0
+          configured baz/1.0.0
+          %info: .+liba.+ is up to date%
+          %info: .+baz.+ is up to date%
+          updated liba/1.0.0
+          updated baz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !baz configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          config.liba.buffer = 1024
+          EOO
+
+        $pkg_drop baz
+      }
+    }
+
+    : proj-detect-unset
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13g && $rep_fetch
+
+      : bar
+      :
+      {
+        $clone_cfg;
+
+        $* bar 2>>EOE != 0
+          <depends-accept-clause>:1:3: error: undefined dependency configuration variable config.liba.x
+            info: was config.liba.x set in earlier prefer or require clause?
+            info: accept condition: ($config.liba.x)
+            info: in depends manifest value of package bar
+          EOE
+      }
+
+      : baz
+      :
+      {
+        $clone_cfg;
+
+        $* baz 2>>EOE != 0
+          <depends-enable-clause>:1:3: error: undefined dependency configuration variable config.liba.x
+            info: was config.liba.x set in earlier prefer or require clause?
+            info: enable condition: ($config.liba.x)
+            info: in depends manifest value of package baz
+          info: while satisfying baz/1.0.0
+          EOE
+      }
+
+      : biz
+      :
+      {
+        $clone_cfg;
+
+        $* biz 2>>EOE != 0
+          <depends-prefer-clause>:1:12: error: undefined dependency configuration variable config.liba.x
+            info: was config.liba.x set in earlier prefer or require clause?
+            info: prefer clause:
+              x = (!$config.liba.x) # Error.
+            info: in depends manifest value of package biz
+          EOE
+      }
+
+      : box
+      :
+      {
+        $clone_cfg;
+
+        $* box 2>>EOE != 0
+          <depends-reflect-clause>:1:12: error: undefined dependency configuration variable config.liba.x
+            info: was config.liba.x set in earlier prefer or require clause?
+            info: reflect clause:
+              x = (!$config.liba.x) # Error.
+            info: in depends manifest value of package box
+          EOE
+      }
+    }
+
+    : proj-cycle
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13h && $rep_fetch
+
+      : bar baz
+      :
+      {
+        $clone_cfg;
+
+        $* bar baz 2>>EOE != 0
+          error: unable to negotiate acceptable configuration between dependents baz, bar for dependencies liba
+            info: configuration before negotiation:
+              config.liba.buffer=4096 (set by bar)
+            info: configuration after negotiation:
+              config.liba.buffer=8192 (set by baz)
+          EOE
+      }
+    }
+
+    : proj-dependency-reflect
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13i && $rep_fetch
+
+      : bar
+      :
+      {
+        $clone_cfg;
+
+        $* bar 2>>~%EOE%;
+          <depends-reflect-clause>:1:5: info: yes
+            info: reflect clause:
+              info ($config.liba.x ? yes : no)
+            info: in depends manifest value of package bar
+          build plan:
+            new liba/1.0.0 (required by bar)
+              config.liba.x=true (set by bar)
+            new bar/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          %info: .+bar.+ is up to date%
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          config.liba.buffer = 1024
+          EOO
+
+        $pkg_drop bar
+      }
+
+      : baz
+      :
+      {
+        $clone_cfg;
+
+        $* baz 2>>~%EOE%;
+          <depends-reflect-clause>:1:5: info: 4096
+            info: reflect clause:
+              info $config.liba.buffer
+            info: in depends manifest value of package baz
+          build plan:
+            new liba/1.0.0 (required by baz)
+              config.liba.buffer=4096 (set by baz)
+            new baz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          configured liba/1.0.0
+          configured baz/1.0.0
+          %info: .+baz.+ is up to date%
+          updated baz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !baz configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = false
+          config.liba.buffer = 4096
+          EOO
+
+        $pkg_drop baz
+      }
+    }
+
+    : proj-non-sensible
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13j && $rep_fetch
+
+      : bar-baz
+      :
+      {
+        $clone_cfg;
+
+        $* bar baz 2>>/~%EOE% != 0
+          error: unable to negotiate sensible configuration for dependency liba
+          %  .+/root.build:5:1: error: buffer must be at least 4096 if feature x is enabled%
+            info: negotiated configuration:
+          %(
+              config.liba.buffer=2048 (set by bar)
+              config.liba.x=true (set by baz)
+          %|
+              config.liba.x=true (set by baz)
+              config.liba.buffer=2048 (set by bar)
+          %)
+          EOE
+      }
+
+      : biz-baz
+      :
+      {
+        $clone_cfg;
+
+        $* biz baz 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by baz, biz)
+          %(
+              config.liba.buffer=4096 (set by biz)
+              config.liba.x=true (set by baz)
+          %|
+              config.liba.x=true (set by baz)
+              config.liba.buffer=4096 (set by biz)
+          %)
+            new biz/1.0.0
+            new baz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched biz/1.0.0
+          unpacked biz/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          configured liba/1.0.0
+          configured biz/1.0.0
+          configured baz/1.0.0
+          %info: .+biz.+ is up to date%
+          %info: .+baz.+ is up to date%
+          updated biz/1.0.0
+          updated baz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !biz configured 1.0.0
+            liba configured 1.0.0
+          !baz configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          config.liba.buffer = 4096
+          EOO
+
+        $pkg_drop biz baz
+      }
+    }
+
+    : proj-unaccept
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13k && $rep_fetch
+
+      : bar-baz
+      :
+      {
+        $clone_cfg;
+
+        $* bar baz 2>>EOE != 0
+          error: unable to negotiate acceptable configuration with dependent bar for dependencies liba
+            info: configuration before negotiation:
+              config.liba.buffer=8192 (set by baz)
+          EOE
+      }
+    }
+
+    : proj-require-system
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13l && $rep_fetch
+
+      : bar
+      :
+      {
+        +$clone_cfg
+
+        : basic
+        :
+        {
+          $clone_cfg;
+
+          $* bar 2>>~%EOE%;
+            build plan:
+              new liba/1.0.0 (required by bar)
+                config.liba.x=true (set by bar)
+              new libb/1.0.0 (required by bar)
+              new bar/1.0.0
+            fetched liba/1.0.0
+            unpacked liba/1.0.0
+            fetched libb/1.0.0
+            unpacked libb/1.0.0
+            fetched bar/1.0.0
+            unpacked bar/1.0.0
+            configured liba/1.0.0
+            configured libb/1.0.0
+            configured bar/1.0.0
+            %info: .+bar.+ is up to date%
+            updated bar/1.0.0
+            EOE
+
+          $pkg_status -r >>EOO;
+            !bar configured 1.0.0
+              liba configured 1.0.0
+              libb configured 1.0.0
+            EOO
+
+          cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+            %.*
+            config.liba.x = true
+            EOO
+
+          $pkg_drop bar
+        }
+
+        : sys-liba-1
+        :
+        {
+          $clone_cfg;
+
+          $* bar '?sys:liba' 2>>~%EOE%;
+            build plan:
+              configure sys:liba/*
+                config.liba.x=true (expected by bar)
+              new libb/1.0.0 (required by bar)
+              new bar/1.0.0
+            fetched libb/1.0.0
+            unpacked libb/1.0.0
+            fetched bar/1.0.0
+            unpacked bar/1.0.0
+            configured sys:liba/*
+            configured libb/1.0.0
+            configured bar/1.0.0
+            %info: .+bar.+ is up to date%
+            updated bar/1.0.0
+            EOE
+
+          $pkg_status -r >>EOO;
+            !bar configured 1.0.0
+              liba configured,system !* available 1.0.0
+              libb configured 1.0.0
+            EOO
+
+          $pkg_drop bar
+        }
+
+        : sys-liba-2
+        :
+        {
+          $clone_cfg;
+
+          $* bar '?sys:liba' +{ config.liba.x=false } 2>>EOE != 0
+            error: unable to negotiate acceptable configuration with dependent bar for dependencies liba
+              info: configuration before negotiation:
+                config.liba.x=false (user configuration)
+            EOE
+        }
+
+        : bar-sys-liba-3
+        :
+        {
+          $clone_cfg;
+
+          $* bar '?sys:liba' +{ config.liba.x=[null] } 2>>EOE != 0
+            error: unable to negotiate acceptable configuration with dependent bar for dependencies liba
+              info: configuration before negotiation:
+                config.liba.x=[null] (user configuration)
+            EOE
+        }
+
+        : sys-liba-4
+        :
+        {
+          $clone_cfg;
+
+          $* bar '?sys:liba' +{ config.liba.x=true } 2>>~%EOE%;
+            build plan:
+              configure sys:liba/*
+                config.liba.x=true (expected user configuration)
+              new libb/1.0.0 (required by bar)
+              new bar/1.0.0
+            fetched libb/1.0.0
+            unpacked libb/1.0.0
+            fetched bar/1.0.0
+            unpacked bar/1.0.0
+            configured sys:liba/*
+            configured libb/1.0.0
+            configured bar/1.0.0
+            %info: .+bar.+ is up to date%
+            updated bar/1.0.0
+            EOE
+
+          $pkg_status -r >>EOO;
+            !bar configured 1.0.0
+              liba configured,system !* available 1.0.0
+              libb configured 1.0.0
+            EOO
+
+          $pkg_drop bar
+        }
+      }
+
+      : baz
+      :
+      {
+        +$clone_cfg
+
+        : basic
+        :
+        {
+          $clone_cfg;
+
+          $* baz 2>>~%EOE%;
+            build plan:
+              new liba/1.0.0 (required by baz)
+                config.liba.x=true (set by baz)
+              new libb/1.0.0 (required by baz)
+              new baz/1.0.0
+            fetched liba/1.0.0
+            unpacked liba/1.0.0
+            fetched libb/1.0.0
+            unpacked libb/1.0.0
+            fetched baz/1.0.0
+            unpacked baz/1.0.0
+            configured liba/1.0.0
+            configured libb/1.0.0
+            configured baz/1.0.0
+            %info: .+baz.+ is up to date%
+            updated baz/1.0.0
+            EOE
+
+          $pkg_status -r >>EOO;
+            !baz configured 1.0.0
+              liba configured 1.0.0
+              libb configured 1.0.0
+            EOO
+
+          cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+            %.*
+            config.liba.x = true
+            EOO
+
+          $pkg_drop baz
+        }
+
+        : sys-liba-1
+        :
+        {
+          $clone_cfg;
+
+          $* baz '?sys:liba' +{ config.liba.x=false } 2>>EOE != 0
+            error: unable to negotiate configuration for system dependency liba without configuration information
+              info: consider specifying system dependency version that has corresponding available package
+              info: dependent baz has prefer/accept clauses that cannot be evaluated without configuration information
+            EOE
+        }
+
+        : sys-liba-2
+        :
+        {
+          $clone_cfg;
+
+          $* baz '?sys:liba/1.0.0' 2>>~%EOE%;
+            build plan:
+              configure sys:liba/1.0.0
+                config.liba.x=true (expected by baz)
+              new libb/1.0.0 (required by baz)
+              new baz/1.0.0
+            fetched libb/1.0.0
+            unpacked libb/1.0.0
+            fetched baz/1.0.0
+            unpacked baz/1.0.0
+            configured sys:liba/1.0.0
+            configured libb/1.0.0
+            configured baz/1.0.0
+            %info: .+baz.+ is up to date%
+            updated baz/1.0.0
+            EOE
+
+          $pkg_status -r >>EOO;
+            !baz configured 1.0.0
+              liba configured,system !1.0.0
+              libb configured 1.0.0
+            EOO
+
+          $pkg_drop baz
+        }
+
+        : sys-liba-3
+        :
+        {
+          $clone_cfg;
+
+          $* baz '?sys:liba/1.0.0' +{ config.liba.x=false } 2>>EOE != 0
+            error: unable to negotiate acceptable configuration with dependent baz for dependencies liba
+              info: configuration before negotiation:
+                config.liba.x=false (user configuration)
+            EOE
+        }
+
+        : bar-sys-liba-4
+        :
+        {
+          $clone_cfg;
+
+          $* baz '?sys:liba/1.0.0' +{ config.liba.x=[null] } 2>>EOE != 0
+            <depends-accept-clause>:1: error: invalid bool value: null
+              info: accept condition: ($config.liba.x)
+              info: in depends manifest value of package baz
+            EOE
+        }
+
+        : sys-liba-5
+        :
+        {
+          $clone_cfg;
+
+          $* baz '?sys:liba/1.0.0' +{ config.liba.x=true } 2>>~%EOE%;
+            build plan:
+              configure sys:liba/1.0.0
+                config.liba.x=true (expected user configuration)
+              new libb/1.0.0 (required by baz)
+              new baz/1.0.0
+            fetched libb/1.0.0
+            unpacked libb/1.0.0
+            fetched baz/1.0.0
+            unpacked baz/1.0.0
+            configured sys:liba/1.0.0
+            configured libb/1.0.0
+            configured baz/1.0.0
+            %info: .+baz.+ is up to date%
+            updated baz/1.0.0
+            EOE
+
+          $pkg_status -r >>EOO;
+            !baz configured 1.0.0
+              liba configured,system !1.0.0
+              libb configured 1.0.0
+            EOO
+
+          $pkg_drop baz
+        }
+      }
+    }
+
+    : proj-require-basics
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13m && $rep_fetch
+
+      : bar
+      :
+      {
+        $clone_cfg;
+
+        $* bar 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar)
+              config.liba.x=true (set by bar)
+            new bar/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          %info: .+bar.+ is up to date%
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          config.liba.y = false
+          config.liba.n = 1024
+          EOO
+
+        $pkg_drop bar
+      }
+
+      : baz
+      :
+      {
+        $clone_cfg;
+
+        $* baz 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar, baz)
+          %(
+              config.liba.y=true (set by baz)
+              config.liba.x=true (set by bar)
+          %|
+              config.liba.x=true (set by bar)
+              config.liba.y=true (set by baz)
+          %)
+            new bar/1.0.0 (required by baz)
+            new baz/1.0.0
+              config.baz.bar=true (set by baz)
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          configured baz/1.0.0
+          %info: .+baz.+ is up to date%
+          updated baz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !baz configured 1.0.0
+            bar configured 1.0.0
+              liba configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/liba-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.liba.x = true
+          config.liba.y = true
+          config.liba.n = 1024
+          EOO
+
+        cat cfg/baz-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.baz.bar = true
+          EOO
+
+        $pkg_drop baz
+      }
+
+      : biz
+      :
+      {
+        $clone_cfg;
+
+        $* biz 2>>EOE != 0
+          error: configuration variable config.liba.x is not set to true
+            info: config.liba.x set in require clause of dependent biz
+            info: require clause:
+              config.liba.x = false # Error: not true
+            info: in depends manifest value of package biz
+          EOE
+      }
+
+      : bix
+      :
+      {
+        $clone_cfg;
+
+        $* bix 2>>EOE != 0
+          error: configuration variable config.liba.n is not of bool type
+            info: config.liba.n set in require clause of dependent bix
+            info: require clause:
+              config.liba.n = 1    # Error: not bool
+            info: in depends manifest value of package bix
+          EOE
+      }
+
+      : box
+      :
+      {
+        $clone_cfg;
+
+        $* box 2>>EOE != 0
+          error: package liba has no configuration variable config.liba.z
+            info: config.liba.z set in require clause of dependent box
+            info: require clause:
+              config.liba.z = true # Error: no such variable
+            info: in depends manifest value of package box
+          EOE
+      }
+    }
+
+    : proj-reflect-append
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13n && $rep_fetch
+
+      : bar
+      :
+      {
+        $clone_cfg;
+
+        $* bar 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar)
+            new libb/1.0.0 (required by bar)
+            new bar/1.0.0
+              config.bar.libs=liba libb (set by bar)
+              config.bar.x=true (set by bar)
+              config.bar.y=true (set by bar)
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched libb/1.0.0
+          unpacked libb/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured libb/1.0.0
+          configured bar/1.0.0
+          %info: .+bar.+ is up to date%
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+            libb configured 1.0.0
+          EOO
+
+        cat cfg/bar-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.bar.x = true
+          config.bar.y = true
+          config.bar.libs = liba libb
+          EOO
+
+        $pkg_drop bar
+      }
+    }
+
+    : proj-reflect-override
+    :
+    {
+      +$clone_root_cfg && $rep_add $rep/t13o && $rep_fetch
+
+      : bar
+      :
+      {
+        $clone_cfg;
+
+        $* bar 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar)
+            new bar/1.0.0
+              config.bar.x=true (set by bar)
+              config.bar.y=true (set by bar)
+              config.bar.z=true (set by bar)
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          %info: .+bar.+ is up to date%
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/bar-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.bar.x = true
+          config.bar.y = true
+          config.bar.z = true
+          EOO
+
+        $pkg_drop bar
+      }
+
+      : bar-config-1
+      :
+      {
+        $clone_cfg;
+
+        $* config.bar.y=true -- bar 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar)
+            new bar/1.0.0
+              config.bar.y=true (user configuration)
+              config.bar.x=true (set by bar)
+              config.bar.z=true (set by bar)
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          %info: .+bar.+ is up to date%
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/bar-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.bar.x = true
+          config.bar.y = true
+          config.bar.z = true
+          EOO
+
+        $pkg_drop bar
+      }
+
+      : bar-config-2
+      :
+      {
+        $clone_cfg;
+
+        $* config.bar.y=false -- bar 2>>EOE != 0
+          error: reflect variable config.bar.y overriden by user configuration
+            info: reflect value: config.bar.y=true
+            info: user value: config.bar.y=false
+            info: reflect clause:
+              config.bar.x = true
+              config.bar.y = true
+              if ($config.origin(config.bar.z) != 'override')
+                config.bar.z = true
+            info: in depends manifest value of package bar
+          info: while satisfying bar/1.0.0
+          EOE
+      }
+
+      : bar-config-3
+      :
+      {
+        $clone_cfg;
+
+        $* config.bar.z=false -- bar 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar)
+            new bar/1.0.0
+              config.bar.z=false (user configuration)
+              config.bar.x=true (set by bar)
+              config.bar.y=true (set by bar)
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          %info: .+bar.+ is up to date%
+          updated bar/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bar configured 1.0.0
+            liba configured 1.0.0
+          EOO
+
+        cat cfg/bar-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.bar.x = true
+          config.bar.y = true
+          config.bar.z = false
+          EOO
+
+        $pkg_drop bar
+      }
+
+      : baz
+      :
+      {
+        $clone_cfg;
+
+        $* baz 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar)
+            new bar/1.0.0 (required by baz)
+              config.bar.y=true (set by baz)
+              config.bar.x=true (set by bar)
+              config.bar.z=true (set by bar)
+            new baz/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          fetched baz/1.0.0
+          unpacked baz/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          configured baz/1.0.0
+          %info: .+baz.+ is up to date%
+          updated baz/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !baz configured 1.0.0
+            bar configured 1.0.0
+              liba configured 1.0.0
+          EOO
+
+        cat cfg/bar-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.bar.x = true
+          config.bar.y = true
+          config.bar.z = true
+          EOO
+
+        $pkg_drop baz
+      }
+
+      : biz
+      :
+      {
+        $clone_cfg;
+
+        $* biz 2>>EOE != 0
+          error: reflect variable config.bar.y overriden by dependent biz
+            info: reflect value: config.bar.y=true
+            info: dependent value: config.bar.y=false
+            info: reflect clause:
+              config.bar.x = true
+              config.bar.y = true
+              if ($config.origin(config.bar.z) != 'override')
+                config.bar.z = true
+            info: in depends manifest value of package bar
+          info: while satisfying bar/1.0.0
+          EOE
+      }
+
+      : biz-bar
+      :
+      {
+        $clone_cfg;
+
+        $* biz ?bar +{ config.bar.y=false } 2>>EOE != 0
+          error: reflect variable config.bar.y overriden by user configuration
+            info: reflect value: config.bar.y=true
+            info: user value: config.bar.y=false
+            info: reflect clause:
+              config.bar.x = true
+              config.bar.y = true
+              if ($config.origin(config.bar.z) != 'override')
+                config.bar.z = true
+            info: in depends manifest value of package bar
+          info: while satisfying bar/1.0.0
+          EOE
+      }
+
+      : bix
+      :
+      {
+        $clone_cfg;
+
+        $* bix 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar)
+            new bar/1.0.0 (required by bix)
+              config.bar.z=false (set by bix)
+              config.bar.x=true (set by bar)
+              config.bar.y=true (set by bar)
+            new bix/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          fetched bix/1.0.0
+          unpacked bix/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          configured bix/1.0.0
+          %info: .+bix.+ is up to date%
+          updated bix/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bix configured 1.0.0
+            bar configured 1.0.0
+              liba configured 1.0.0
+          EOO
+
+        cat cfg/bar-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.bar.x = true
+          config.bar.y = true
+          config.bar.z = false
+          EOO
+
+        $pkg_drop bix
+      }
+
+      : bix-bar
+      :
+      {
+        $clone_cfg;
+
+        $* bix ?bar +{ config.bar.z=false } 2>>~%EOE%;
+          build plan:
+            new liba/1.0.0 (required by bar)
+            new bar/1.0.0
+              config.bar.z=false (user configuration)
+              config.bar.x=true (set by bar)
+              config.bar.y=true (set by bar)
+            new bix/1.0.0
+          fetched liba/1.0.0
+          unpacked liba/1.0.0
+          fetched bar/1.0.0
+          unpacked bar/1.0.0
+          fetched bix/1.0.0
+          unpacked bix/1.0.0
+          configured liba/1.0.0
+          configured bar/1.0.0
+          configured bix/1.0.0
+          %info: .+bar.+ is up to date%
+          %info: .+bix.+ is up to date%
+          updated bar/1.0.0
+          updated bix/1.0.0
+          EOE
+
+        $pkg_status -r >>EOO;
+          !bix configured 1.0.0
+            bar configured 1.0.0
+              liba configured 1.0.0
+          EOO
+
+        cat cfg/bar-1.0.0/build/config.build >>~%EOO%;
+          %.*
+          config.bar.x = true
+          config.bar.y = true
+          config.bar.z = false
+          EOO
+
+        $pkg_drop bix
+      }
+    }
+  }
 }
 
 : test-dependency
@@ -5335,7 +13995,8 @@ test.options += --no-progress
   +cp -r $src/libhello-1.0.0 ./libhello
   +cat <<EOI >+libhello/build/root.build
     config [bool] config.libhello.develop ?= false
-    text "develop=$config.libhello.develop"
+    if ($build.mode != 'skeleton')
+      text "develop=$config.libhello.develop"
     EOI
   +$rep_add libhello --type dir
   +$rep_fetch
@@ -6838,24 +15499,76 @@ else
 
       $rep_add -d t2 $rep/t7a && $rep_fetch -d t2;
 
-      $* ?foo libbaz +{ --config-name t2 } <<EOI 2>>~%EOE%;
+      $* ?foo libbaz +{ --config-name t2 } --verbose 5 <<EOI 2>>~%EOE%;
         y
         EOI
+        %.*
+        trace: pkg_build: refine package collection/plan execution from scratch
+        %.*
+        %trace: collect_build: add libbaz/1.0.0 \[t2.\]%
+        %trace: collect_build_prerequisites: begin libbaz/1.0.0 \[t2.\]%
+        %trace: collect_build_prerequisites: end libbaz/1.0.0 \[t2.\]%
+        %.*
+        trace: collect_build_prerequisites: begin foo/1.0.0
+        %.*
+        %trace: collect_build_prerequisites: no cfg-clause for dependency libbaz/1.0.0 \[t2.\] of dependent foo/1.0.0%
+        trace: collect_build_prerequisites: end foo/1.0.0
+        %.*
+        trace: execute_plan: simulate: yes
+        %.*
+        trace: evaluate_dependency: libbaz/1.0.0: unused
+        %.*
+        trace: evaluate_dependency: foo/1.0.0: unused
+        %.*
+        trace: pkg_build: refine package collection/plan execution
+        %.*
+        trace: collect_drop: foo/1.0.0 package version needs to be replaced with drop
+        trace: pkg_build: collection failed due to package version replacement, retry from scratch
+        %.*
+        trace: pkg_build: refine package collection/plan execution from scratch
+        %.*
+        %trace: collect_build: add libbaz/1.0.0 \[t2.\]%
+        %trace: collect_build_prerequisites: begin libbaz/1.0.0 \[t2.\]%
+        %trace: collect_build_prerequisites: end libbaz/1.0.0 \[t2.\]%
+        trace: collect_build: apply version replacement for foo/1.0.0
+        trace: collect_build: replacement: drop
+        %.*
+        trace: execute_plan: simulate: yes
+        %.*
+        %trace: evaluate_dependency: libbuild2-bar/1.0.0 \[t1..bpkg.build2.\]: unused%
+        %.*
+        trace: pkg_build: refine package collection/plan execution
+        %.*
+        trace: execute_plan: simulate: yes
+        %.*
         %  new libbaz/1.0.0 \[t2.\]%
         %  drop libbuild2-bar/1.0.0 \[t1..bpkg.build2.\] \(unused\)%
           drop libbaz/1.0.0 (unused)
           drop foo/1.0.0 (unused)
-        continue? [Y/n] disfigured foo/1.0.0
+        continue? [Y/n] trace: execute_plan: simulate: no
+        %.*
+        disfigured foo/1.0.0
+        %.*
         disfigured libbaz/1.0.0
+        %.*
         %disfigured libbuild2-bar/1.0.0 \[t1..bpkg.build2.\]%
+        %.*
         %fetched libbaz/1.0.0 \[t2.\]%
+        %.*
         %unpacked libbaz/1.0.0 \[t2.\]%
+        %.*
         %purged libbuild2-bar/1.0.0 \[t1..bpkg.build2.\]%
+        %.*
         purged libbaz/1.0.0
+        %.*
         purged foo/1.0.0
+        %.*
         %configured libbaz/1.0.0 \[t2.\]%
-        %info: t2.+libbaz-1.0.0.+ is up to date%
+        %.*
+        %info: .+t2.+libbaz-1.0.0.+ is up to date%
+        %.*
         %updated libbaz/1.0.0 \[t2.\]%
+        %.*
         EOE
 
       $pkg_status -d t1 --link -r >>/EOO
diff --git a/tests/pkg-build/t11a b/tests/pkg-build/t11a
new file mode 120000
index 0000000..4f78412
--- /dev/null
+++ b/tests/pkg-build/t11a
@@ -0,0 +1 @@
+../common/dependency-alternatives/t11a
\ No newline at end of file
diff --git a/tests/pkg-build/t12a b/tests/pkg-build/t12a
new file mode 120000
index 0000000..d421f92
--- /dev/null
+++ b/tests/pkg-build/t12a
@@ -0,0 +1 @@
+../common/satisfy/t12a/
\ No newline at end of file
diff --git a/tests/pkg-build/t12b b/tests/pkg-build/t12b
new file mode 120000
index 0000000..0fbba8a
--- /dev/null
+++ b/tests/pkg-build/t12b
@@ -0,0 +1 @@
+../common/satisfy/t12b/
\ No newline at end of file
diff --git a/tests/pkg-build/t13a b/tests/pkg-build/t13a
new file mode 120000
index 0000000..9d8fb23
--- /dev/null
+++ b/tests/pkg-build/t13a
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13a/
\ No newline at end of file
diff --git a/tests/pkg-build/t13b b/tests/pkg-build/t13b
new file mode 120000
index 0000000..d17701b
--- /dev/null
+++ b/tests/pkg-build/t13b
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13b/
\ No newline at end of file
diff --git a/tests/pkg-build/t13c b/tests/pkg-build/t13c
new file mode 120000
index 0000000..1c534d0
--- /dev/null
+++ b/tests/pkg-build/t13c
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13c/
\ No newline at end of file
diff --git a/tests/pkg-build/t13d b/tests/pkg-build/t13d
new file mode 120000
index 0000000..6933497
--- /dev/null
+++ b/tests/pkg-build/t13d
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13d/
\ No newline at end of file
diff --git a/tests/pkg-build/t13e b/tests/pkg-build/t13e
new file mode 120000
index 0000000..d8d84cc
--- /dev/null
+++ b/tests/pkg-build/t13e
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13e/
\ No newline at end of file
diff --git a/tests/pkg-build/t13f b/tests/pkg-build/t13f
new file mode 120000
index 0000000..bf556bc
--- /dev/null
+++ b/tests/pkg-build/t13f
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13f/
\ No newline at end of file
diff --git a/tests/pkg-build/t13g b/tests/pkg-build/t13g
new file mode 120000
index 0000000..4dc8eb4
--- /dev/null
+++ b/tests/pkg-build/t13g
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13g/
\ No newline at end of file
diff --git a/tests/pkg-build/t13h b/tests/pkg-build/t13h
new file mode 120000
index 0000000..f99413a
--- /dev/null
+++ b/tests/pkg-build/t13h
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13h/
\ No newline at end of file
diff --git a/tests/pkg-build/t13i b/tests/pkg-build/t13i
new file mode 120000
index 0000000..bba4fd3
--- /dev/null
+++ b/tests/pkg-build/t13i
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13i/
\ No newline at end of file
diff --git a/tests/pkg-build/t13j b/tests/pkg-build/t13j
new file mode 120000
index 0000000..da120da
--- /dev/null
+++ b/tests/pkg-build/t13j
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13j/
\ No newline at end of file
diff --git a/tests/pkg-build/t13k b/tests/pkg-build/t13k
new file mode 120000
index 0000000..b1e5a14
--- /dev/null
+++ b/tests/pkg-build/t13k
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13k/
\ No newline at end of file
diff --git a/tests/pkg-build/t13l b/tests/pkg-build/t13l
new file mode 120000
index 0000000..40d9561
--- /dev/null
+++ b/tests/pkg-build/t13l
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13l/
\ No newline at end of file
diff --git a/tests/pkg-build/t13m b/tests/pkg-build/t13m
new file mode 120000
index 0000000..0154455
--- /dev/null
+++ b/tests/pkg-build/t13m
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13m/
\ No newline at end of file
diff --git a/tests/pkg-build/t13n b/tests/pkg-build/t13n
new file mode 120000
index 0000000..1ed57ca
--- /dev/null
+++ b/tests/pkg-build/t13n
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13n/
\ No newline at end of file
diff --git a/tests/pkg-build/t13o b/tests/pkg-build/t13o
new file mode 120000
index 0000000..9516f8f
--- /dev/null
+++ b/tests/pkg-build/t13o
@@ -0,0 +1 @@
+../common/dependency-alternatives/t13o/
\ No newline at end of file