splent-cli 1.40.0__tar.gz → 1.41.0__tar.gz

{splent_cli-1.40.0/src/splent_cli.egg-info → splent_cli-1.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.40.0
+Version: 1.41.0
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 License-Expression: LGPL-3.0-or-later

{splent_cli-1.40.0 → splent_cli-1.41.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.40.0"
+version = "1.41.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"

{splent_cli-1.40.0 → splent_cli-1.41.0}/src/splent_cli/commands/database/db_status.py

@@ -58,9 +58,22 @@ def _get_filesystem_head(mdir: str) -> str | None:
     "db:status",
     short_help="Show migration status for all features.",
 )
+@click.option(
+    "--check",
+    is_flag=True,
+    help="Exit 1 when a feature's schema is not at the head of its migrations "
+    "(pending, not applied, or applied from scripts that are gone).",
+)
 @context.requires_product
-def db_status():
-    """Show migration status: DB revision vs filesystem head for each feature."""
+def db_status(check):
+    """Show migration status: DB revision vs filesystem head for each feature.
+
+    \b
+    --check is for a start that must not serve on a schema older than its
+    code: the product's entrypoint runs it with SPLENT_MIGRATE_ON_START=check,
+    when a deploy agent migrates in a step of its own. An orphan (a feature
+    no longer declared) does not count.
+    """
     app = current_app
 
     click.echo(click.style("\n📊 Migration Status\n", fg="cyan", bold=True))
@@ -151,7 +164,7 @@ def db_status():
     if issues:
         click.secho(
             f"  {issues} feature(s) out of sync. Run 'splent db:upgrade' to apply pending migrations.",
-            fg="yellow",
+            fg="red" if check else "yellow",
         )
         click.echo()
     if orphans:
@@ -164,6 +177,8 @@ def db_status():
             fg="red",
         )
         click.echo()
+    if check and issues:
+        raise SystemExit(1)
 
 
 cli_command = db_status

{splent_cli-1.40.0 → splent_cli-1.41.0}/src/splent_cli/commands/feature/feature_create.py

@@ -276,7 +276,8 @@ def _build_file_map(feature_type, short_name, docker=False, js=False):
         src = {
             "__init__.py": f"{T}feature_init_service.py.j2",
             "config.py": f"{T}feature_config.py.j2",
-            "services.py": f"{T}feature_services.py.j2",
+            # No models, so no repository for the service to wrap.
+            "services.py": f"{T}feature_services_service.py.j2",
             "signals.py": f"{T}feature_signals.py.j2",
             "commands.py": f"{T}feature_commands.py.j2",
         }

{splent_cli-1.40.0 → splent_cli-1.41.0}/src/splent_cli/commands/feature/feature_test.py

@@ -46,12 +46,15 @@ def _tied_to_the_cli(command: str, lock: str = TEST_LOCK) -> str:
     The CLI holds the exec's stdin open while it runs (see
     _delegate_to_web_container). When the CLI goes, stdin closes, and the
     watcher stops the whole run. A run that finds another one holding the
-    lock waits for it instead of running beside it.
+    lock waits for it instead of running beside it. The lock is opened for
+    reading, which flock needs no more than: a run as the workspace's user
+    shares the file a run as root created.
     """
     return f"""set -m
 exec 3<&0
 if command -v flock >/dev/null 2>&1; then
-  exec 9>{lock}
+  [ -e {lock} ] || : > {lock}
+  exec 9<{lock}
   if ! flock -n 9; then
     echo "  Another test run is using this product's test database. Waiting for it to finish..."
     flock 9
@@ -84,13 +87,78 @@ def _delegate_to_web_container(argv: list[str]) -> None:
     )
 
 
+def workspace_user(container: str) -> list[str]:
+    """The docker exec options that run a command in CONTAINER as the user
+    who owns the workspace.
+
+    An exec runs as the image's user, root in a development image, and a
+    test run writes into the working copies: bytecode, .pytest_cache, what
+    the tests leave. As root they stayed root's, and the next release of
+    the feature could not rewrite them. The owner is read from the
+    workspace's files, whoever this process runs as. A development image
+    has no account for that uid as a rule; Docker runs a bare uid all the
+    same, and the exec then names it in USER and LOGNAME, which
+    getpass.getuser() reads before the account it does not find (pymysql
+    asks it), with HOME a directory of its own under /tmp. A workspace root
+    owns stays root's, and so does a container where the account cannot be
+    looked up.
+    """
+    owner = _workspace_owner()
+    if owner is None or owner[0] == 0:
+        return []
+    uid, gid = owner
+    found = run(
+        ["docker", "exec", container, "getent", "passwd", str(uid)],
+        check=False,
+        capture=True,
+    )
+    if found.returncode not in (0, 2):
+        # 2 is getent's "no such entry"; anything else is a container that
+        # cannot answer, where the exec keeps the image's user.
+        return []
+    options = ["-u", f"{uid}:{gid}"]
+    fields = (found.stdout or "").strip().split(":")
+    if found.returncode != 0 or len(fields) < 6 or not fields[5]:
+        user = _account_name(uid)
+        options += [
+            "-e",
+            f"HOME=/tmp/splent-home-{uid}",
+            "-e",
+            f"USER={user}",
+            "-e",
+            f"LOGNAME={user}",
+        ]
+    return options
+
+
+def _account_name(uid: int) -> str:
+    """The name this machine gives UID, ``splent`` when it gives none."""
+    import pwd
+
+    try:
+        return pwd.getpwuid(uid).pw_name
+    except KeyError:
+        return "splent"
+
+
+def _workspace_owner() -> tuple[int, int] | None:
+    """``(uid, gid)`` of the workspace's root directory, or None."""
+    try:
+        owner = context.workspace().stat()
+    except OSError:
+        return None
+    return owner.st_uid, owner.st_gid
+
+
 def run_tests_in_web_container(product: str, argv: list[str]) -> int:
     """Run ``splent <argv>`` in PRODUCT's web container, as a test run.
 
     Returns its exit code, or 1 when the container is not running. The run
     waits for any other test run in that container and stops when this
-    process does (see :func:`_tied_to_the_cli`). feature:test runs there
-    this way, and so do the product's own tests (product:test).
+    process does (see :func:`_tied_to_the_cli`), and runs as the workspace's
+    owner (:func:`workspace_user`). feature:test runs there this way, and so
+    do the product's own tests (product:test) and the release gate, which
+    runs feature:test.
     """
     name = web_container.name(product)
     if not _container_running(name):
@@ -121,6 +189,7 @@ def run_tests_in_web_container(product: str, argv: list[str]) -> int:
                 "docker",
                 "exec",
                 "-i",
+                *workspace_user(name),
                 "-e",
                 f"SPLENT_APP={product}",
                 *passthrough,
@@ -694,15 +763,19 @@ def _run_neutral(
     problem = neutral_app.database_problem(dict(os.environ))
     if problem:
         _neutral_refusal(problem)
-    missing = neutral_app.missing_distributions(members)
-    if missing:
-        product = context.require_app()
+    product = context.require_app()
+    unmet = neutral_app.unmet_requirements(members)
+    from_workspace = [str(u) for u in unmet if not u.installable]
+    if from_workspace:
+        # The framework, the CLI and the features are the workspace's
+        # copies, which a run never replaces with a release.
         _neutral_refusal(
-            f"The neutral app needs packages that {product}'s image does not\n"
-            "   have at the version asked for:\n"
-            + "\n".join(f"     {line}" for line in missing)
-            + "\n   Install them in the container, or run the tests in a product\n"
-            "   that declares the feature."
+            f"The neutral app needs SPLENT packages that {product}'s container\n"
+            "   does not have at the version asked for:\n"
+            + "\n".join(f"     {line}" for line in from_workspace)
+            + "\n   The container has the workspace's copies of them. Update the\n"
+            "   working copy, or run the tests in a product that declares the\n"
+            "   feature."
         )
 
     test_paths = _collect_test_paths([(feature.name, feature.root)])
@@ -710,15 +783,33 @@ def _run_neutral(
         click.secho("⚠️  No test directories found.", fg="yellow")
         return
 
-    click.secho(
-        f"\n🧪 Running tests for {feature_ref} in a neutral app "
-        f"[{', '.join(levels)}]...",
-        fg="cyan",
-    )
     with tempfile.TemporaryDirectory(prefix="splent-neutral-") as tmp:
+        venv_dir = None
+        if unmet:
+            click.echo(
+                f"  {product}'s image lacks what these need, so the run installs "
+                "it in a\n  virtual environment of its own, removed after it:"
+            )
+            for line in unmet:
+                click.echo(f"    {line}")
+            try:
+                venv_dir = neutral_app.install_requirements(Path(tmp), unmet)
+            except neutral_app.NeutralAppError as e:
+                _neutral_refusal(
+                    f"{e}\n   Install them in the container, or run the tests "
+                    "in a product\n   that declares the feature."
+                )
+        click.secho(
+            f"\n🧪 Running tests for {feature_ref} in a neutral app "
+            f"[{', '.join(levels)}]...",
+            fg="cyan",
+        )
         neutral_app.write_app(Path(tmp), members)
-        env = neutral_app.environment(Path(tmp), members)
-        _run_pytest(test_paths, levels, keyword, verbose, environment=env)
+        env = neutral_app.environment(Path(tmp), members, venv_dir=venv_dir)
+        python = str(venv_dir / "bin" / "python") if venv_dir else None
+        _run_pytest(
+            test_paths, levels, keyword, verbose, environment=env, python=python
+        )
 
 
 def _resolve_levels(unit, integration, functional, e2e, load) -> tuple[str, ...]:
@@ -744,12 +835,15 @@ def _run_pytest(
     verbose: bool,
     extra_sources: list[tuple[str, Path]] = (),
     environment: dict | None = None,
+    python: str | None = None,
 ):
     """Run each feature's tests, level by level, and exit 1 if any failed.
 
     ENVIRONMENT, when given, is the whole environment of every run (the
     neutral app's). Otherwise each run gets this process's, with the import
-    path and the feature sources of the active product.
+    path and the feature sources of the active product. PYTHON, when given,
+    is the interpreter that runs pytest (the neutral app's virtual
+    environment).
     """
     passed = failed = skipped = 0
     for pkg, test_dir, src_dir in test_paths:
@@ -790,7 +884,7 @@ def _run_pytest(
                 )
 
             cmd = [
-                "pytest",
+                *([python, "-m", "pytest"] if python else ["pytest"]),
                 str(level_dir),
                 "--rootdir=.",
                 "-W",

{splent_cli-1.40.0 → splent_cli-1.41.0}/src/splent_cli/commands/product/product_auto_require.py

@@ -15,6 +15,8 @@ from splent_cli.commands.uvl.uvl_utils import (
     list_all_features_from_uvl as _list_all_features_from_uvl,
     extract_implications_from_uvl_text as _extract_implications_from_uvl_text,
     print_uvl_header as _print_uvl_header,
+    parameter_nodes_of as _parameter_nodes_of,
+    parameters_to_set as _parameters_to_set,
 )
 from splent_cli.utils.ci_workflow import keeps_ci_workflows
 
@@ -172,10 +174,17 @@ def product_complete(pyproject, default_org, yes, dry_run):
 
     # current selection from pyproject: the one product:validate checks, the
     # base list plus the list of the current environment (dev when unset)
-    deps = read_features_from_data(data, context.resolve_env())
+    env = context.resolve_env()
+    deps = read_features_from_data(data, env)
     selected_names = {_normalize_feature_name(d) for d in deps}
     selected_names.add(root_name)  # root always selected
 
+    # The nodes the product's values select count as selected (P7), and a
+    # parameter node a constraint asks for is a value to set in
+    # [tool.splent.config]: it has no package, and is never added.
+    nodes, chosen = _parameter_nodes_of(workspace, data, local_uvl, selected_names, env)
+    selected_names |= set(chosen)
+
     # compute missing via implications
     pairs = _extract_implications_from_uvl_text(uvl_text)
     req_graph = _build_req_graph(pairs)
@@ -185,6 +194,18 @@ def product_complete(pyproject, default_org, yes, dry_run):
 
     # filter out root just in case
     missing_names = [f for f in missing_names if f != root_name]
+    missing_values = [f for f in missing_names if f in nodes]
+    missing_names = [f for f in missing_names if f not in nodes]
+
+    def say_values():
+        if missing_values:
+            to_set = _parameters_to_set(missing_values, nodes, workspace, data, env)
+            click.secho(
+                "Not added, values to set in [tool.splent.config]: "
+                + ", ".join(to_set),
+                fg="yellow",
+            )
+            click.echo()
 
     # sanity
     unknown_missing = sorted([f for f in missing_names if f not in universe_set])
@@ -195,6 +216,7 @@ def product_complete(pyproject, default_org, yes, dry_run):
 
     if not missing_names:
         _print_uvl_header("complete", app_name, local_uvl, len(universe))
+        say_values()
         click.echo("OK: nothing to add (no missing dependencies).")
         click.echo()
         return
@@ -213,6 +235,7 @@ def product_complete(pyproject, default_org, yes, dry_run):
         to_add_specs.append(spec)
 
     _print_uvl_header("complete", app_name, local_uvl, len(universe))
+    say_values()
     click.echo("Missing features (by name):")
     for f in missing_names:
         click.echo(f"- {f}")

{splent_cli-1.40.0 → splent_cli-1.41.0}/src/splent_cli/commands/product/product_build.py

@@ -824,16 +824,34 @@ def _reset_features_dir(docker_path: str) -> None:
 # with a one-shot service must declare restart: "no", quoted.
 RESTART_POLICY = "unless-stopped"
 
-# The web container's health probe. Python is the one interpreter every
-# production image has, so the probe needs no extra package (curl is not
-# guaranteed). Any answer below 500 counts as healthy: a product without a
-# public home answers 302 or 404 at "/", and that still proves gunicorn and
-# the app are serving. A refused connection, a timeout or a 5xx does not.
+# The web container's health probe, which product:deploy waits on too.
+# Python is the one interpreter every production image has, so the probe
+# needs no extra package (curl is not guaranteed). It asks the framework's
+# /readyz (splent_framework 1.21 and later): 200 when the database and the
+# services the product declares answer, 503 when they do not. The framework
+# answers it before the app's own code runs, so TRUSTED_HOSTS never sees
+# it. "/" did not do: with TRUSTED_HOSTS set it answers 400 to a request
+# for 127.0.0.1, and a broken database could still serve a cached page.
+# Any other answer at /readyz comes from the app's own routes: a framework
+# older than 1.21, or a product that turned the probe off. That app is
+# healthy when "/" answers below 500, the probe it had before.
 WEB_HEALTH_PROBE = (
+    "import http.client as h\n"
+    "def status(path):\n"
+    "    c = h.HTTPConnection('127.0.0.1', 5000, timeout=4)\n"
+    "    c.request('GET', path)\n"
+    "    return c.getresponse().status\n"
+    "ready = status('/readyz')\n"
+    "ok = ready == 200 if ready in (200, 503) else status('/') < 500\n"
+    "raise SystemExit(not ok)\n"
+)
+# The probe CLIs before 1.41 wrote, which product:build replaces with the
+# one above: a product created with them has it in its prod compose file.
+LEGACY_WEB_HEALTH_PROBES = (
     "import http.client as h; "
     "c = h.HTTPConnection('127.0.0.1', 5000, timeout=4); "
     "c.request('GET', '/'); "
-    "raise SystemExit(c.getresponse().status >= 500)"
+    "raise SystemExit(c.getresponse().status >= 500)",
 )
 WEB_HEALTHCHECK = {
     "test": ["CMD", "python3", "-c", WEB_HEALTH_PROBE],
@@ -906,9 +924,11 @@ def local_or_registry_image(product: str) -> str:
 
 def apply_production_policies(compose_data: dict, product: str) -> dict:
     """Give every deployed service a restart policy, and the web and database
-    services a healthcheck, unless the compose file already set one. The web
-    image becomes ``${SPLENT_IMAGE:-<product>:latest}``, so a host can run the
-    image a release published instead of building its own.
+    services a healthcheck, unless the compose file already set one. A web
+    healthcheck that is the probe an older CLI wrote (it asked "/") is
+    brought up to WEB_HEALTH_PROBE. The web image becomes
+    ``${SPLENT_IMAGE:-<product>:latest}``, so a host can run the image a
+    release published instead of building its own.
 
     Applied by product:build to the merged deploy compose, so every product
     gets it on its next build, whatever its docker-compose.prod.yml says and
@@ -924,7 +944,12 @@ def apply_production_policies(compose_data: dict, product: str) -> dict:
         None,
     )
     if web_name and isinstance(services[web_name], dict):
-        services[web_name].setdefault("healthcheck", dict(WEB_HEALTHCHECK))
+        healthcheck = services[web_name].setdefault(
+            "healthcheck", dict(WEB_HEALTHCHECK)
+        )
+        test = healthcheck.get("test") if isinstance(healthcheck, dict) else None
+        if isinstance(test, list) and test and test[-1] in LEGACY_WEB_HEALTH_PROBES:
+            healthcheck["test"] = list(WEB_HEALTHCHECK["test"])
         # The local build, unless deploy/.env names a registry image. Only the
         # plain local name is rewritten: an image the product chose on purpose
         # is left alone.

{splent_cli-1.40.0 → splent_cli-1.41.0}/src/splent_cli/commands/product/product_configure.py

@@ -26,9 +26,11 @@ from dataclasses import dataclass, field
 
 import click
 
+from splent_cli.commands.uvl.uvl_utils import ModelTree
 from splent_cli.services import context
 from splent_cli.utils.feature_utils import normalize_namespace
 from splent_cli.utils.ci_workflow import keeps_ci_workflows
+from splent_cli.utils.uvl_params import PARAM, VALUE
 
 
 # ═══════════════════════════════════════════════════════════════════
@@ -47,11 +49,19 @@ class SPLFeature:
     groups: list[SPLGroup] = field(default_factory=list)
     card_min: int = 1  # feature cardinality lower bound
     card_max: int = 1  # feature cardinality upper bound
+    attributes: dict[str, str] = field(default_factory=dict)
 
     @property
     def is_abstract(self) -> bool:
         return not self.package
 
+    @property
+    def is_parameter(self) -> bool:
+        """Whether the node stands for a parameter or one of its values (P7,
+        splent_cli.utils.uvl_params): the product's [tool.splent.config]
+        selects it, and it is never offered as a feature."""
+        return bool({PARAM, VALUE} & set(self.attributes))
+
 
 @dataclass
 class SPLGroup:
@@ -157,6 +167,18 @@ class SPLModel:
                             stack.append(ch)
         return result
 
+    def is_parameter(self, name: str) -> bool:
+        f = self.features.get(name)
+        return bool(f and f.is_parameter)
+
+    def tree(self) -> ModelTree:
+        """The model as uvl_params reads it: parents and attributes."""
+        return ModelTree(
+            root=self.root_name,
+            parents={n: f.parent for n, f in self.features.items() if f.parent},
+            attributes={n: dict(f.attributes) for n, f in self.features.items()},
+        )
+
     def groups_needing_selection(self) -> list[tuple[str, SPLGroup]]:
         """Return (parent_name, group) pairs that require interactive selection.
 
@@ -305,6 +327,7 @@ def _load_spl_model(uvl_path: str, spl_name: str) -> SPLModel:
             org=attrs.get("org", "splent-io"),
             package=attrs.get("package", ""),
             parent=parent_name,
+            attributes=attrs,
         )
         model.features[node.name] = feat
 
@@ -376,6 +399,10 @@ def propagate(
     Backward:
       4. A selected ∧ (A excludes B) → B excluded
       5. B excluded ∧ (A ⇒ B) → A excluded  (contrapositive)
+
+    A parameter node B is never selected by rule 1: only a value of the
+    parameter selects it (:func:`_parameter_selection`), and the solver
+    says when the values do not.
     """
     result = set(selected) | mandatory
     excl = set(excluded) if excluded else set()
@@ -386,8 +413,8 @@ def propagate(
         # Forward implication
         for c in model.constraints:
             if c.kind == "implies" and c.source in result and c.target not in result:
-                if c.target in excl:
-                    continue  # conflict — SAT validation will catch
+                if c.target in excl or model.is_parameter(c.target):
+                    continue  # conflict, or a value to set — SAT validation will catch
                 result.add(c.target)
                 changed = True
 
@@ -649,7 +676,9 @@ def _propagate_and_report(
     """Run propagation, update sets in-place, and report changes."""
     new_sel, new_excl = propagate(selected, model, mandatory, excluded)
 
-    auto = new_sel - selected - mandatory
+    # A parameter's node (one that holds its choices, as a mandatory child)
+    # is not news: its value is the product's to set.
+    auto = {n for n in new_sel - selected - mandatory if not model.is_parameter(n)}
     for name in sorted(auto):
         click.echo(
             f"{prefix}\u21b3 {name}" + click.style("  (auto-selected)", fg="cyan")
@@ -708,6 +737,9 @@ def _configure_subtree(
         # Only prompt if this feature is active
         if name not in selected and name not in mandatory:
             continue
+        # The values of a parameter: [tool.splent.config] picks them.
+        if all(model.is_parameter(ch) for ch in group.children):
+            continue
 
         label_map = {
             "alternative": "pick exactly one",
@@ -761,7 +793,10 @@ def _configure_subtree(
     has_optionals = any(
         g.group_type == "optional"
         for g in feat.groups
-        if any(ch not in mandatory and ch not in selected for ch in g.children)
+        if any(
+            ch not in mandatory and ch not in selected and not model.is_parameter(ch)
+            for ch in g.children
+        )
     )
     showed_header = False
 
@@ -769,6 +804,10 @@ def _configure_subtree(
         if group.group_type != "optional":
             continue
         for ch in group.children:
+            # A parameter, which [tool.splent.config] sets, not a feature.
+            if model.is_parameter(ch):
+                continue
+
             # Already handled by mandatory set
             if ch in mandatory:
                 _configure_subtree(ch, selected, excluded, model, mandatory, indent)
@@ -832,6 +871,55 @@ def _configure_subtree(
 # ═══════════════════════════════════════════════════════════════════
 
 
+def _feature_root(workspace: str, org: str, package: str) -> str | None:
+    """The copy of a feature this workspace has: its working copy at the
+    root, else its newest release in the cache, else None."""
+    from splent_cli.services.neutral_app import cache_dir, cached_versions
+
+    root = os.path.join(workspace, package)
+    if os.path.isfile(os.path.join(root, "pyproject.toml")):
+        return root
+    namespace = normalize_namespace(org)
+    for version in cached_versions(workspace, namespace, package):
+        return str(cache_dir(workspace, namespace, package, version))
+    return None
+
+
+def _parameter_selection(
+    workspace: str, data: dict, model: SPLModel, selected: set[str]
+) -> dict[str, str]:
+    """The parameter nodes the product's values select (P7), each with what
+    selected it, for the features in ``selected``.
+
+    The values are the product's [tool.splent.config], else each feature's
+    default, read from the copy of the feature this workspace has. The
+    configurator asks for none of them: [tool.splent.config] is where they
+    change, and product:params shows them.
+    """
+    from splent_framework.params.schema import read_pyproject
+
+    from splent_cli.utils.uvl_params import selection
+
+    params: dict = {}
+    for name in sorted(selected):
+        feat = model.features.get(name)
+        if not feat or feat.is_abstract:
+            continue
+        root = _feature_root(workspace, feat.org, feat.package)
+        if root is None:
+            continue
+        try:
+            with open(os.path.join(root, "pyproject.toml"), "rb") as f:
+                declared = read_pyproject(feat.package, tomllib.load(f))
+        except (OSError, tomllib.TOMLDecodeError):
+            continue
+        for key, param in declared.params.items():
+            params.setdefault(key, param)
+    splent = data.get("tool", {}).get("splent", {})
+    config = splent.get("config", {}) if isinstance(splent, dict) else {}
+    return selection(model.tree(), params, config if isinstance(config, dict) else {})
+
+
 def _read_contract_env(
     workspace: str,
     cache_dir: str,
@@ -939,7 +1027,7 @@ def product_configure():
     # ── Show mandatory leaf features ───────────────────────
     click.secho("  Mandatory (auto-selected):", fg="green")
     for name in sorted(mandatory):
-        if name == model.root_name:
+        if name == model.root_name or model.is_parameter(name):
             continue
         feat = model.features[name]
         has_selection_group = any(
@@ -955,6 +1043,15 @@ def product_configure():
     # ── Build final selection ──────────────────────────────
     all_selected, _ = propagate(selected, model, mandatory, excluded)
 
+    # ── The parameter nodes the product's values select ────
+    # They count as selected, as product:validate counts them, and what
+    # they imply comes with them (a home ordered by rating needs rating).
+    chosen = _parameter_selection(workspace, data, model, all_selected)
+    if chosen:
+        all_selected, _ = propagate(
+            all_selected | set(chosen), model, mandatory, excluded
+        )
+
     # ── Summary ────────────────────────────────────────────
     click.echo()
     click.secho("  \u2500\u2500\u2500 Configuration \u2500\u2500\u2500", bold=True)
@@ -968,7 +1065,9 @@ def product_configure():
             pass  # skip root display
         elif name in all_selected:
             tag = ""
-            if name in mandatory:
+            if name in chosen:
+                tag = click.style(f"  ({chosen[name]})", fg="cyan")
+            elif name in mandatory:
                 tag = click.style("  (mandatory)", fg="bright_black")
             click.echo(f"{pfx}\u2713 {name}{tag}")
         else:
@@ -980,6 +1079,13 @@ def product_configure():
 
     render_tree(model.root_name)
     click.echo()
+    if any(f.is_parameter for f in model.features.values()):
+        click.secho(
+            "  The nodes of parameters follow the product's [tool.splent.config], "
+            "or each feature's\n  default. splent product:params shows the values.",
+            fg="bright_black",
+        )
+        click.echo()
 
     # ── Check excludes ─────────────────────────────────────
     violations = check_excludes(all_selected, model)
@@ -1013,6 +1119,12 @@ def product_configure():
     if not ok:
         click.secho("UNSATISFIABLE", fg="red", bold=True)
         click.echo("  The selected configuration violates UVL constraints.")
+        if any(f.is_parameter for f in model.features.values()):
+            click.echo(
+                "  A value of a parameter may need a feature left out, or a feature "
+                "a value\n  [tool.splent.config] does not set: splent product:params "
+                "shows the values."
+            )
         raise SystemExit(1)
 
     click.secho("satisfiable", fg="green", bold=True)