splent-cli 1.34.0__tar.gz → 1.35.0__tar.gz

{splent_cli-1.34.0/src/splent_cli.egg-info → splent_cli-1.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.34.0
+Version: 1.35.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.34.0 → splent_cli-1.35.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.34.0"
+version = "1.35.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.34.0 → splent_cli-1.35.0}/src/splent_cli/cli.py

@@ -11,6 +11,15 @@ from splent_cli.utils.command_loader import load_commands
 load_dotenv()
 
 
+def _missing_module(exc: BaseException) -> str | None:
+    """The module whose absence made building the app fail, if that is why."""
+    while exc is not None:
+        if isinstance(exc, ModuleNotFoundError) and exc.name:
+            return exc.name
+        exc = exc.__cause__ or exc.__context__
+    return None
+
+
 class SPLENTCLI(click.Group):
     """
     Main SPLENT CLI class.
@@ -101,15 +110,53 @@ class SPLENTCLI(click.Group):
 
     # ── App context injection ─────────────────────────────────────
 
+    def _delegate_to_the_product(self, ctx) -> None:
+        """Run this command in the product's web container, and exit with its
+        code; return when that container is not running.
+
+        Called only when the app cannot be built here: building it imports
+        what the features declare, which the product's image installs and the
+        CLI's may not (see services/web_container.py).
+        """
+        from splent_cli.services import web_container
+
+        product = os.getenv("SPLENT_APP")
+        if not product or web_container.is_product_container():
+            return
+        if not web_container.running(web_container.name(product)):
+            return
+        argv = [*ctx.protected_args, *ctx.args]
+        raise SystemExit(web_container.delegate(product, argv))
+
     def invoke(self, ctx):
         cmd_name = ctx.protected_args[0] if ctx.protected_args else None
         command = self.get_command(ctx, cmd_name)
 
+        # A feature's own commands are only found by building the app, so
+        # here they may be missing although the product has them.
+        if command is None and cmd_name and cmd_name.startswith("feature:"):
+            self._delegate_to_the_product(ctx)
+
         if command and getattr(command, "requires_app", False):
             from splent_cli.utils.dynamic_imports import get_app
             from splent_cli.utils.db_utils import check_db_connection
 
-            app = get_app()
+            try:
+                app = get_app()
+            except Exception as exc:
+                missing = _missing_module(exc)
+                if missing is None:
+                    raise
+                # Only then: where the app builds here, the command runs here
+                # with the tools the CLI image has (ruff formats migrations).
+                self._delegate_to_the_product(ctx)
+                product = os.getenv("SPLENT_APP", "The product")
+                raise click.ClickException(
+                    f"{product}'s features need {missing}, which the product's "
+                    "image installs and the CLI's does not.\n"
+                    "  Start the product (splent product:up --dev) and run the "
+                    "command again: it then runs in the product's web container."
+                ) from exc
             if getattr(command, "requires_db", False):
                 if not check_db_connection(app):
                     raise SystemExit(1)

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_compat.py

@@ -411,6 +411,141 @@ def _analyse_all(labeled_contracts: list[tuple[str, dict]]) -> list[dict]:
     return sorted(findings, key=lambda f: SEVERITY_ORDER[f["severity"]])
 
 
+def _contract_env(path: Path) -> str | None:
+    """The environment a feature's contract confines it to, if any."""
+    pyproject = path / "pyproject.toml"
+    if not pyproject.exists():
+        return None
+    data = load_toml(pyproject, what=f"pyproject.toml for {path.name}")
+    return data.get("tool", {}).get("splent", {}).get("contract", {}).get("env")
+
+
+def env_scope_findings(workspace: str, product_dir: str) -> list[dict]:
+    """Features confined to one environment, in a list that installs them in
+    the other.
+
+    mailhog and phpmyadmin declare env = "dev" in their contract. In the base
+    list the production image installed them too, phpMyAdmin with autologin
+    to the database, and nothing said so.
+    """
+    from splent_framework.utils.pyproject_reader import PyprojectReader
+
+    reader = PyprojectReader.for_product(product_dir)
+    lists = {
+        "features": reader.features,
+        "features_dev": reader.features_dev,
+        "features_prod": reader.features_prod,
+    }
+    findings = []
+    for key, entries in lists.items():
+        for entry in entries:
+            ns, name, version = _parse_pyproject_entry(entry)
+            path = product_feature_dir(workspace, product_dir, ns, name, version)
+            if path is None:
+                continue
+            scope = _contract_env(path)
+            short = name.removeprefix("splent_feature_")
+            if scope == "dev" and key != "features_dev":
+                message = (
+                    f"{short} is a development tool (its contract says env = "
+                    f'"dev"), but [tool.splent] {key} puts it in the production '
+                    "image too. Move it to features_dev."
+                )
+            elif scope == "prod" and key == "features_dev":
+                message = (
+                    f"{short} only runs in production (its contract says env = "
+                    '"prod"), but it is in [tool.splent] features_dev. Move it '
+                    "to features_prod."
+                )
+            else:
+                continue
+            findings.append(
+                {
+                    "severity": "error",
+                    "field": "env",
+                    "message": message,
+                    "features": [short],
+                }
+            )
+    return findings
+
+
+def _joins_the_shared_network(compose_file: Path) -> bool:
+    """Whether a compose file puts its services on the shared splent_network
+    instead of the product's own (``name: ${SPLENT_NETWORK:-splent_network}``)."""
+    import yaml
+
+    try:
+        data = yaml.safe_load(compose_file.read_text()) or {}
+    except (OSError, yaml.YAMLError):
+        return False
+    networks = data.get("networks") or {}
+    spec = networks.get("splent_network")
+    if not isinstance(spec, dict) or not spec.get("external"):
+        return False
+    return "SPLENT_NETWORK" not in str(spec.get("name", ""))
+
+
+def network_findings(workspace: str, product_dir: str) -> list[dict]:
+    """Feature services the product cannot reach.
+
+    Each product has a network of its own, and a feature's services join it
+    through SPLENT_NETWORK. mailhog and phpmyadmin named the shared network
+    instead, so the app could not send mail to Mailhog and phpMyAdmin could
+    not reach the database, and nothing said why.
+    """
+    from splent_framework.utils.pyproject_reader import PyprojectReader
+
+    reader = PyprojectReader.for_product(product_dir)
+    findings = []
+    for entry in reader.features + reader.features_dev + reader.features_prod:
+        ns, name, version = _parse_pyproject_entry(entry)
+        path = product_feature_dir(workspace, product_dir, ns, name, version)
+        if path is None:
+            continue
+        files = sorted((path / "docker").glob("docker-compose*.yml"))
+        if any(_joins_the_shared_network(f) for f in files):
+            short = name.removeprefix("splent_feature_")
+            findings.append(
+                {
+                    "severity": "error",
+                    "field": "docker",
+                    "message": (
+                        f"{short}'s services join the shared splent_network, "
+                        "where the product's app cannot reach them. Its compose "
+                        "file needs name: ${SPLENT_NETWORK:-splent_network} "
+                        "under networks.splent_network."
+                    ),
+                    "features": [short],
+                }
+            )
+    return findings
+
+
+def naming_findings(workspace: str, product_dir: str) -> list[dict]:
+    """Features named after a product (auth_uvlhub). A warning, so the debt
+    shows in every validation until the product drops them."""
+    from splent_framework.utils.pyproject_reader import PyprojectReader
+
+    from splent_cli.utils.feature_naming import product_suffix, product_suffix_message
+
+    reader = PyprojectReader.for_product(product_dir)
+    findings = []
+    for entry in reader.features + reader.features_dev + reader.features_prod:
+        _, name, _ = _parse_pyproject_entry(entry)
+        product = product_suffix(name, workspace)
+        if product:
+            findings.append(
+                {
+                    "severity": "warning",
+                    "field": "name",
+                    "message": product_suffix_message(name, product),
+                    "features": [name.removeprefix("splent_feature_")],
+                }
+            )
+    return findings
+
+
 def run_all_product_check(workspace: str, product_dir: str) -> list[dict]:
     """Run the full product compatibility check. Returns findings list."""
     try:

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_create.py

@@ -9,13 +9,11 @@ from splent_cli.utils.feature_utils import (
     require_valid_feature_ref,
 )
 from splent_cli.services import context
+from splent_cli.utils.feature_naming import product_suffix, product_suffix_message
 
-try:
-    from importlib.metadata import version as _pkg_version
+from splent_cli.utils.running_version import cli_version as _running_cli_version
 
-    _CLI_VERSION = _pkg_version("splent_cli")
-except Exception:
-    _CLI_VERSION = "dev"
+_CLI_VERSION = _running_cli_version()
 
 
 FEATURE_TYPES = ("full", "light", "config", "service")
@@ -226,6 +224,12 @@ def make_feature(full_name, feature_type, docker):
 
     # --- Target directory (workspace root for editable features) ---
     workspace = str(context.workspace())
+
+    product = product_suffix(feature_name, workspace)
+    if product:
+        click.secho(f"❌ {product_suffix_message(feature_name, product)}", fg="red")
+        raise SystemExit(1)
+
     feature_dir = os.path.join(workspace, feature_name)
     src_path = os.path.join(feature_dir, "src", org_safe, feature_name)
 

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_detach.py

@@ -25,7 +25,7 @@ from splent_cli.utils.manifest import (
 
 @click.command(
     "feature:detach",
-    short_help="Unregister a versioned feature from the active product (cache is kept).",
+    short_help="Unpin a released version: the entry goes back to editable (cache is kept).",
 )
 @click.argument("feature_identifier", required=True)
 @click.argument("version", required=True)
@@ -36,9 +36,10 @@ from splent_cli.utils.manifest import (
 )
 def feature_detach(feature_identifier, version, force):
     """
-    Detach a versioned feature from the active product.
+    Unpin a released version, the reverse of feature:attach.
 
-    - Removes namespace/feature@version from pyproject.toml
+    - Drops @version from the entry in pyproject.toml, which stays as the
+      bare, editable namespace/feature (feature:remove takes it out)
     - Removes symlink in features/<namespace>/
     - Leaves .splent_cache intact
     """

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_env.py

@@ -119,7 +119,10 @@ def feature_env(feature_name, generate, env_name):
 
     if selected:
         try:
-            shutil.copy(selected, env_file)
+            # copyfile, not copy: a pinned feature's cache is read-only, and
+            # copying the mode made its .env read-only too, so product:env
+            # --merge failed writing __FEATURE_HOST_DIR__ into it.
+            shutil.copyfile(selected, env_file)
         except OSError as exc:
             click.echo(f"❌ Failed to create {env_file} from {selected}: {exc}")
             raise SystemExit(1)

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_refine.py

@@ -14,6 +14,7 @@ from pathlib import Path
 import click
 
 from splent_cli.services import context
+from splent_cli.utils.feature_naming import product_suffix, product_suffix_message
 from splent_cli.utils.feature_utils import normalize_namespace, read_features_from_data
 from splent_cli.utils.refinement_facts import (
     FeatureSource,
@@ -1009,6 +1010,12 @@ def feature_refinement(refiner_name):
     # A feature other features refine cannot refine anything (a chain)
     _refuse_if_refined(_get_product_features(workspace, product), refiner_name)
 
+    # A refiner named after a product is a product patch, not variability.
+    named_after = product_suffix(refiner_name, workspace)
+    if named_after:
+        click.secho(f"  {product_suffix_message(refiner_name, named_after)}", fg="red")
+        raise SystemExit(1)
+
     # Check if refinement already configured
     refiner_data = load_toml(refiner_pyproject, what=f"{refiner_name} pyproject.toml")
     existing_refinement = (

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_remove.py

@@ -24,7 +24,7 @@ from splent_cli.utils.manifest import (
 
 @click.command(
     "feature:remove",
-    short_help="Unregister an editable feature from the active product (keeps files).",
+    short_help="Remove a feature from the active product, pinned or editable (keeps files).",
 )
 @click.argument("feature_name", required=True)
 @click.option("--namespace", "-n", help="Namespace (defaults to 'splent-io').")
@@ -47,9 +47,10 @@ from splent_cli.utils.manifest import (
 )
 def feature_remove(feature_name, namespace, env_scope, force):
     """
-    Removes a local feature (no version, no repo) from the current SPLENT product:
-    - Removes entry from [features] in pyproject.toml
-    - Removes symlink under /workspace/<product>/features/<namespace>/<feature_name>
+    Removes a feature from the current SPLENT product, pinned or editable:
+    - Removes its entry from the feature lists in pyproject.toml
+    - Removes its symlink under /workspace/<product>/features/<namespace>/
+    The checkout and the cached release stay on disk.
 
     \b
     Without flags every list is searched (features, features_dev, features_prod).

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_test.py

@@ -13,7 +13,7 @@ from splent_cli.utils.feature_utils import (
     get_normalize_feature_name_in_splent_format,
     parse_feature_entry,
 )
-from splent_cli.services import context
+from splent_cli.services import context, web_container
 
 
 # Test levels in execution order (default = first three)
@@ -21,28 +21,13 @@ TEST_LEVELS = ("unit", "integration", "functional", "e2e", "load")
 DEFAULT_LEVELS = ("unit", "integration", "functional")
 
 
-def _is_product_container() -> bool:
-    """Whether this process already runs inside the product's web container.
-
-    SPLENT_CONTAINER is the explicit answer when set (the CLI container says
-    "cli", product images say "product"); /.dockerenv covers containers older
-    than the variable.
-    """
-    container = os.getenv("SPLENT_CONTAINER")
-    if container:
-        return container != "cli"
-    return os.path.exists("/.dockerenv")
+# Shared with every command that needs the product's app (see cli.py).
+_is_product_container = web_container.is_product_container
+_container_running = web_container.running
 
 
 def _web_container() -> str:
-    return f"{context.require_app()}_web"
-
-
-def _container_running(name: str) -> bool:
-    result = run(
-        ["docker", "ps", "-q", "-f", f"name=^{name}$"], check=False, capture=True
-    )
-    return result.returncode == 0 and bool(result.stdout.strip())
+    return web_container.name(context.require_app())
 
 
 _PASSTHROUGH_ENV = ("PYTEST_ADDOPTS", "PYTHONDONTWRITEBYTECODE")

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/product/product_build.py

@@ -9,6 +9,7 @@ import click
 from splent_cli.services import context, compose, deploy_bundle
 from splent_cli.services.preflight import run_preflight
 from splent_cli.utils.feature_utils import read_features_from_data
+from splent_cli.utils.running_version import cli_version
 from splent_cli.utils.io_utils import (
     atomic_write,
     env_line,
@@ -406,26 +407,6 @@ def framework_version(workspace: str) -> str:
         )
 
 
-def cli_version() -> str:
-    """The version of the CLI that is running, the one the image installs too.
-
-    Read from the source tree it runs from when that is a checkout: an
-    editable install records its version once, when it is installed, and the
-    checkout moves on with every release.
-    """
-    from importlib.metadata import version
-    from pathlib import Path
-
-    import splent_cli
-
-    pyproject = Path(splent_cli.__file__).resolve().parents[2] / "pyproject.toml"
-    if pyproject.is_file():
-        project = load_toml(str(pyproject)).get("project", {})
-        if project.get("name") == "splent_cli" and project.get("version"):
-            return str(project["version"])
-    return version("splent_cli")
-
-
 def runtime_pins(workspace: str) -> dict:
     """{package: version} the production image installs from PyPI."""
     return {

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/product/product_create.py

@@ -20,12 +20,9 @@ from splent_cli.utils.template_drift import (
 )
 from splent_cli.utils.template_drift import _forge_host as _template_forge_host
 
-try:
-    from importlib.metadata import version as _pkg_version
+from splent_cli.utils.running_version import cli_version as _running_cli_version
 
-    _CLI_VERSION = _pkg_version("splent_cli")
-except Exception:
-    _CLI_VERSION = "dev"
+_CLI_VERSION = _running_cli_version()
 
 
 PRODUCT_NAME_RE = re.compile(r"^[a-z_][a-z0-9_]*$")

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/product/product_resolve.py

@@ -9,7 +9,7 @@ from splent_cli.utils.feature_utils import (
     parse_feature_entry,
     read_features_from_data,
 )
-from splent_cli.utils.cache_utils import make_feature_writable
+from splent_cli.utils.cache_utils import make_feature_writable, restore_snapshot
 
 
 def _splent_list(data: dict, key: str) -> list[str]:
@@ -194,11 +194,18 @@ def product_sync(ctx, force, yes, mode=None, strict=False):
                         failed += 1
                         continue
 
+            restored = [] if cloned else restore_snapshot(cache_dir)
             _create_symlink(cache_dir, product_features_dir, link_path)
             marker = click.style("  ✓", fg="green")
             label = f"  {short:<{max_w_r}}"
             ver = click.style(f"  {version}", dim=True)
             src = click.style("  cached" if not cloned else "  cloned", dim=True)
+            if restored:
+                src += click.style(
+                    f"  restored {len(restored)} file(s) to the release: "
+                    + ", ".join(restored),
+                    fg="yellow",
+                )
             tag = _feature_env_tag(entry, dev_set, prod_set)
             click.echo(f"  {marker}{label}{ver}{src}{tag}")
 

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/product/product_sync_template.py

@@ -2,8 +2,9 @@ import click
 from pathlib import Path
 
 from splent_cli.services import context
-from splent_cli.utils.io_utils import atomic_write
+from splent_cli.utils.io_utils import atomic_write, load_toml
 from splent_cli.utils.template_drift import (
+    CLI_VERSION,
     PRODUCT_GROUPS,
     count_changed_lines,
     file_diff,
@@ -12,6 +13,23 @@ from splent_cli.utils.template_drift import (
     resolve_product_dir,
     resolve_product_rel,
 )
+from splent_cli.utils.toml_edit import write_toml
+
+
+def _record_cli_version(product_path: Path) -> None:
+    """Store the CLI whose templates the product now matches.
+
+    product:drift reports it as "generated with CLI vX". Only product:create
+    wrote it, so a product brought fully up to date kept naming the CLI it was
+    created with. A partial sync (--scripts, --docker...) leaves it alone,
+    because the other groups may still be older.
+    """
+    pyproject = product_path / "pyproject.toml"
+    data = load_toml(pyproject, what="pyproject.toml")
+    splent = data.setdefault("tool", {}).setdefault("splent", {})
+    if splent.get("cli_version") != CLI_VERSION:
+        splent["cli_version"] = CLI_VERSION
+        write_toml(pyproject, data)
 
 
 @click.command(
@@ -112,6 +130,8 @@ def product_sync_template(
                 changes[rel_path] = (abs_path, expected, n)
 
     if not changes:
+        if not filter_active and not dry_run:
+            _record_cli_version(product_path)
         click.echo()
         click.secho("  ✅ All SPLENT-owned files are already up to date.", fg="green")
         click.echo()
@@ -138,6 +158,8 @@ def product_sync_template(
         # Atomic: an interrupted run never leaves a half-written script.
         atomic_write(abs_path, expected)
         click.secho(f"  ✔  {rel_path}", fg="green")
+    if not filter_active:
+        _record_cli_version(product_path)
 
     click.echo()
     click.secho("  Done.", fg="cyan")

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/product/product_validate.py

@@ -110,9 +110,17 @@ def _run_sat_check(workspace, app_name, data, feature_list, print_config):
 
 def _run_compat_check(workspace, product_dir):
     """Run contract compatibility check. Returns (findings, errors, warnings)."""
-    from splent_cli.commands.feature.feature_compat import run_all_product_check
+    from splent_cli.commands.feature.feature_compat import (
+        env_scope_findings,
+        naming_findings,
+        network_findings,
+        run_all_product_check,
+    )
 
     findings = run_all_product_check(workspace, product_dir)
+    findings += env_scope_findings(workspace, product_dir)
+    findings += network_findings(workspace, product_dir)
+    findings += naming_findings(workspace, product_dir)
     errors = [f for f in findings if f["severity"] == "error"]
     warnings = [f for f in findings if f["severity"] == "warning"]
     return findings, errors, warnings

{splent_cli-1.34.0 → splent_cli-1.35.0}/src/splent_cli/commands/release/release_resume.py

@@ -21,7 +21,7 @@ something is already wrong:
 
 and two more keep what it publishes equal to what the tag says:
 
-  * origin/main only ever receives the commit the tag describes, as a
+  * the release branch on origin only ever receives the commit the tag describes, as a
     fast-forward. A divergence leaves the forge half stuck, never a tag on a
     commit no remote branch contains
   * nothing is built from uncommitted changes, and the Docker image, whose
@@ -153,25 +153,26 @@ def _is_ancestor(path: str, ancestor: str, descendant: str) -> bool:
 
 
 def plan_main_push(path: str, tag: str) -> tuple[str, str | None]:
-    """How origin/main comes to carry the commit *tag* describes.
+    """How the release branch on origin comes to carry the commit *tag* describes.
 
     Returns ``(state, sha)``, where *sha* is the commit that is or will be
     tagged: the tag's commit when the tag exists locally, otherwise HEAD,
     because that is where the tag will be created. Never HEAD when a tag
     exists, since the operator may have committed more work since.
 
-    ``contained``  origin/main already has it, nothing to push
-    ``push``       pushing it is a fast-forward of origin/main
+    ``contained``  origin already has it on the branch, nothing to push
+    ``push``       pushing it is a fast-forward of that branch
     ``diverged``   it is neither, so no tag can be published on it
-    ``unknown``    there is no origin/main to compare with, nothing is pushed
+    ``unknown``    origin has no such branch to compare with, nothing is pushed
     ``timeout``    origin did not answer in time, so nothing can be compared
     """
+    branch = release.release_branch(path)
     ref = (
         f"refs/tags/{tag}^{{commit}}" if release.local_tag_exists(path, tag) else "HEAD"
     )
     try:
         subprocess.run(
-            ["git", "fetch", "origin", "main"],
+            ["git", "fetch", "origin", branch],
             cwd=path,
             capture_output=True,
             env=_non_interactive_env(),
@@ -180,7 +181,7 @@ def plan_main_push(path: str, tag: str) -> tuple[str, str | None]:
     except subprocess.TimeoutExpired:
         return "timeout", _git_out(path, ["rev-parse", "--verify", ref])
     sha = _git_out(path, ["rev-parse", "--verify", ref])
-    remote = _git_out(path, ["rev-parse", "--verify", "refs/remotes/origin/main"])
+    remote = _git_out(path, ["rev-parse", "--verify", f"refs/remotes/origin/{branch}"])
     if not sha or not remote:
         return "unknown", sha
     if sha == remote or _is_ancestor(path, sha, remote):
@@ -191,10 +192,11 @@ def plan_main_push(path: str, tag: str) -> tuple[str, str | None]:
 
 
 def push_commit_to_main(path: str, sha: str) -> str | None:
-    """Fast-forward origin/main to *sha*. None on success, else the reason."""
+    """Fast-forward the release branch on origin to *sha*. None on success, else the reason."""
+    branch = release.release_branch(path)
     try:
         r = subprocess.run(
-            ["git", "push", "origin", f"{sha}:refs/heads/main"],
+            ["git", "push", "origin", f"{sha}:refs/heads/{branch}"],
             cwd=path,
             capture_output=True,
             text=True,
@@ -207,7 +209,7 @@ def push_commit_to_main(path: str, sha: str) -> str | None:
         )
     if r.returncode != 0:
         return (r.stderr or "").strip() or f"git push exited {r.returncode}"
-    click.echo(f"  push     origin/main updated to {sha[:12]}")
+    click.echo(f"  push     origin/{branch} updated to {sha[:12]}")
     return None
 
 
@@ -419,7 +421,7 @@ def release_resume(target, assume_yes, no_pypi, no_forge, no_github, no_docker,
             push_tag = make_release = False
             main_sha = None
             summary = (
-                f"origin/main and the commit {tag} describes have diverged, so "
+                f"origin/{release.release_branch(path)} and the commit {tag} describes have diverged, so "
                 "the tag was not pushed"
                 if main_state == "diverged"
                 else "origin did not answer 'git fetch' within "
@@ -522,7 +524,9 @@ def release_resume(target, assume_yes, no_pypi, no_forge, no_github, no_docker,
 
     steps = []
     if main_sha:
-        steps.append(f"push {main_sha[:12]} to origin/main, the commit {tag} describes")
+        steps.append(
+            f"push {main_sha[:12]} to origin/{release.release_branch(path)}, the commit {tag} describes"
+        )
     if upload:
         steps.append(f"build and upload {package} {normalized} to PyPI")
     if push_tag:
@@ -590,9 +594,9 @@ def release_resume(target, assume_yes, no_pypi, no_forge, no_github, no_docker,
             stuck.append(
                 release_gate.ChannelStatus(
                     release_gate.FORGE,
-                    summary=f"could not push {main_sha[:12]} to origin/main, {failure}",
+                    summary=f"could not push {main_sha[:12]} to origin/{release.release_branch(path)}, {failure}",
                     hints=[
-                        "Fix the push to origin/main, then run "
+                        f"Fix the push to origin/{release.release_branch(path)}, then run "
                         f"'splent release:resume {hint_target}' again.",
                     ],
                 )
@@ -604,7 +608,7 @@ def release_resume(target, assume_yes, no_pypi, no_forge, no_github, no_docker,
                     push_image=push_image,
                     summary=f"not built, there is no {tag} to build it from",
                     hint=f"Nothing is built before {tag} exists. Fix the push "
-                    f"to origin/main, then run 'splent release:resume "
+                    f"to origin/{release.release_branch(path)}, then run 'splent release:resume "
                     f"{hint_target}' again.",
                 )
                 upload = push_image = False