rosotacom-dev 2.5.dev10__tar.gz → 2.5.dev13__tar.gz

{rosotacom_dev-2.5.dev10 → rosotacom_dev-2.5.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev10
+Version: 2.5.dev13
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause
@@ -439,7 +439,11 @@ rosotacom ota-smoke 2_native_chatter \
 
 `ota-smoke` accepts sessions and scenarios. It puts rosotacom on each peer,
 stages the active project, runs delivery and isolation checks, collects
-artifacts, stops the run, and removes the remote workdir. Add `--interactive`
+artifacts, stops the run, and removes the remote workdir. For scenario targets
+the checks start only once every declared application container is running
+(bounded at 10 minutes, covering a cold peer's first image build); an
+application that never comes up fails the run by name instead of as missing
+publishers. Add `--interactive`
 for a local control tmux with
 one attachable communication/catmux window per peer with a live status pane below
 each one. Scenario targets also get one native application-container window per

{rosotacom_dev-2.5.dev10 → rosotacom_dev-2.5.dev13}/README.md

@@ -394,7 +394,11 @@ rosotacom ota-smoke 2_native_chatter \
 
 `ota-smoke` accepts sessions and scenarios. It puts rosotacom on each peer,
 stages the active project, runs delivery and isolation checks, collects
-artifacts, stops the run, and removes the remote workdir. Add `--interactive`
+artifacts, stops the run, and removes the remote workdir. For scenario targets
+the checks start only once every declared application container is running
+(bounded at 10 minutes, covering a cold peer's first image build); an
+application that never comes up fails the run by name instead of as missing
+publishers. Add `--interactive`
 for a local control tmux with
 one attachable communication/catmux window per peer with a live status pane below
 each one. Scenario targets also get one native application-container window per

{rosotacom_dev-2.5.dev10 → rosotacom_dev-2.5.dev13}/src/rosotacom/cli.py

@@ -143,6 +143,10 @@ OTA_DEFAULT_SUDO_MODE = "passwordless"
 # meet this because they call an absolute path inside the workdir; checkout mode
 # calls the peer's own command by name, so it has to say where that lives.
 OTA_CHECKOUT_PATH_PREFIX = 'export PATH="$HOME/.local/bin:$PATH"; '
+#: Set for a `--peer-exec` transport when the script it is about to run needs a
+#: terminal on the far side. A transport that does not understand it is not
+#: broken by it, which is why this is an environment variable and not a flag.
+OTA_PEER_TTY_ENV = "ROSOTACOM_PEER_TTY"
 
 ws_creation_dir = WS_DIR / "session" / "creation"
 session_gen_path = ws_creation_dir / "generate_session_files.py"
@@ -1750,11 +1754,23 @@ def _ota_peer_target(peer: OtaSmokePeer) -> str:
 def _ota_remote_argv(peer: OtaSmokePeer, script: str, *, tty: bool = False, batch: bool = False) -> list[str]:
     # A named transport wins over the SSH alias, and it takes the script as its
     # last argument because that is the contract `ssh host <script>` already
-    # has. `tty` and `batch` are dropped on purpose rather than guessed at:
-    # they are options of one particular client, and a transport that is not
-    # ssh has no obligation to understand them.
+    # has. `batch` is dropped rather than guessed at: it is an option of one
+    # particular client, and a transport that is not ssh has no obligation to
+    # understand it.
+    #
+    # `tty` is not droppable, and assuming it was cost a two-host run. The peer
+    # windows start their container with `docker run -i -t`, which refuses
+    # outright when the far side has no terminal — so a transport that cannot be
+    # told "this one is interactive" can carry the probes and not the experiment.
+    # It travels as an environment variable rather than an argument because the
+    # argv contract is what makes any command usable here: a transport that
+    # ignores the variable behaves exactly as before instead of failing on a
+    # flag it never agreed to parse.
     if peer.exec_command:
-        return [*shlex.split(peer.exec_command), script]
+        argv = shlex.split(peer.exec_command)
+        if tty:
+            argv = ["env", f"{OTA_PEER_TTY_ENV}=1", *argv]
+        return [*argv, script]
     if peer.ssh:
         argv = ["ssh"]
         if batch:
@@ -3433,6 +3449,55 @@ def _ota_stop_peers(
         _ota_run(peer, command, label=f"{peer_name}: stop {target.name}", dry_run=dry_run, check=False)
 
 
+# How long verification waits for a scenario application container before it
+# gives up. Covers a first-run image build on a cold peer (observed ~3 min for
+# an apt-get install alone); the communication-container readiness wait uses
+# the same bound.
+OTA_SMOKE_APPLICATION_WAIT_TIMEOUT_S = 600
+
+
+def _ota_wait_for_scenario_applications(
+    target: InteractiveSmokeTarget,
+    plan: OtaSmokePlan,
+    *,
+    dry_run: bool,
+) -> list[str]:
+    """Block until every scenario application container declared for the target
+    is running on its peer. The application windows start their container only
+    after the peer's communication container is up, so on a cold machine the
+    first check would otherwise run against applications that are still being
+    built and report their absence as missing publishers (#218). A session
+    target declares no applications and passes through untouched.
+
+    Running is deliberately the whole bound: whether an application *produces*
+    is exactly what the session's own expectations then check."""
+    definition = target.scenario_definition
+    if definition is None:
+        return []
+    errors: list[str] = []
+    for peer_name in sorted(plan.peers):
+        peer = plan.peers[peer_name]
+        for application in definition.applications.get(peer_name, ()):
+            suffix = _sanitize_docker_name(f"_scenario_{target.name}_{peer_name}_{application.name}")
+            label = f"{peer_name}: wait for application {application.name}"
+            script = _ota_wait_for_running_container_suffix_script(
+                suffix,
+                f"{peer_name}:application:{application.name}",
+                timeout_s=OTA_SMOKE_APPLICATION_WAIT_TIMEOUT_S,
+            )
+            result = _ota_run(peer, script, label=label, dry_run=dry_run, check=False)
+            if result.returncode != 0:
+                _ota_print_failure_output(label, result)
+                errors.append(
+                    f"{peer_name}: application '{application.name}' has no running container after "
+                    f"{OTA_SMOKE_APPLICATION_WAIT_TIMEOUT_S}s; the scenario never came up, so its "
+                    "topics were not checked"
+                )
+            else:
+                _print_completed_output(result)
+    return errors
+
+
 def _ota_verify_only(args: argparse.Namespace) -> int:
     _runtime, plan, target = _resolve_ota_smoke_context(args)
     instance_id = getattr(args, "instance_id", None)
@@ -3440,6 +3505,11 @@ def _ota_verify_only(args: argparse.Namespace) -> int:
         raise RuntimeError("ota-smoke --verify-only requires --instance-id.")
     dry_run = bool(getattr(args, "dry_run", False))
     print(f"OTA smoke verification starting: {target.name} ({target.target_type}), instance={instance_id}")
+    errors = _ota_wait_for_scenario_applications(target, plan, dry_run=dry_run)
+    if errors:
+        for error in errors:
+            print(f"OTA SMOKE ERROR: {error}", file=sys.stderr)
+        return 1
     print("OTA smoke: starting synthetic publishers where needed.")
     _ota_start_session_publishers(target, plan, dry_run=dry_run)
     errors = _ota_verify_delivery(target, plan, instance_id, dry_run=dry_run)
@@ -3452,15 +3522,35 @@ def _ota_verify_only(args: argparse.Namespace) -> int:
     return 0
 
 
-def _ota_wait_for_running_container_suffix_script(suffix: str, label: str) -> str:
+def _ota_wait_for_running_container_suffix_script(suffix: str, label: str, timeout_s: int | None = None) -> str:
     pattern = shlex.quote(f"{re.escape(suffix)}$")
     quoted_label = shlex.quote(label)
-    return (
-        "container=''; "
-        f"until container=$(docker ps --filter status=running --format '{{{{.Names}}}}' "
+    find_container = (
+        f"container=$(docker ps --filter status=running --format '{{{{.Names}}}}' "
         f"| grep -E {pattern} | head -n 1) "
-        '&& [ -n "$container" ]; do '
-        f"echo '[INFO] waiting for running container:' {quoted_label}; "
+        '&& [ -n "$container" ]'
+    )
+    if timeout_s is None:
+        return (
+            "container=''; "
+            f"until {find_container}; do "
+            f"echo '[INFO] waiting for running container:' {quoted_label}; "
+            "sleep 2; "
+            "done; "
+            'echo "[INFO] found running container: $container"'
+        )
+    # Bounded variant for captured (non-interactive) callers: one line up front
+    # instead of a poll-cadence echo, and a hard failure when the bound is hit.
+    attempts = max(1, int(timeout_s) // 2)
+    return (
+        f"echo '[INFO] waiting up to {int(timeout_s)}s for running container:' {quoted_label}; "
+        "container=''; tries=0; "
+        f"until {find_container}; do "
+        "tries=$((tries+1)); "
+        f'if [ "$tries" -ge {attempts} ]; then '
+        f"echo '[ERROR] no running container after {int(timeout_s)}s:' {quoted_label} >&2; "
+        "exit 1; "
+        "fi; "
         "sleep 2; "
         "done; "
         'echo "[INFO] found running container: $container"'
@@ -3534,7 +3624,7 @@ def _ota_create_tmux(
             session_name,
             "-n",
             _safe_path_token(f"{first_peer.name}_communication"),
-            _ota_quote_cmd(_ota_remote_argv(first_peer, first_script, tty=bool(first_peer.ssh))),
+            _ota_quote_cmd(_ota_remote_argv(first_peer, first_script, tty=_ota_peer_is_remote(first_peer))),
         ),
         text=True,
         capture_output=True,
@@ -3614,7 +3704,7 @@ def _ota_create_tmux(
                 session_name,
                 "-n",
                 _safe_path_token(f"{peer.name}_communication"),
-                _ota_quote_cmd(_ota_remote_argv(peer, script, tty=bool(peer.ssh))),
+                _ota_quote_cmd(_ota_remote_argv(peer, script, tty=_ota_peer_is_remote(peer))),
             ),
             text=True,
             capture_output=True,
@@ -3645,7 +3735,7 @@ def _ota_create_tmux(
                         session_name,
                         "-n",
                         _safe_path_token(f"{peer.name}_{application.name}"),
-                        _ota_quote_cmd(_ota_remote_argv(peer, application_script, tty=bool(peer.ssh))),
+                        _ota_quote_cmd(_ota_remote_argv(peer, application_script, tty=_ota_peer_is_remote(peer))),
                     ),
                     text=True,
                     capture_output=True,
@@ -3810,7 +3900,7 @@ def _start_interactive_ota_smoke(args: argparse.Namespace) -> int:
     if target.target_type == "scenario":
         for peer_name, peer in plan.peers.items():
             attach = _ota_rosotacom_command(plan, ["scenario", "attach", target.name, "--identity", peer_name], peer)
-            attach_cmd = _ota_quote_cmd(_ota_remote_argv(peer, attach, tty=bool(peer.ssh)))
+            attach_cmd = _ota_quote_cmd(_ota_remote_argv(peer, attach, tty=_ota_peer_is_remote(peer)))
             print(f"Manual remote scenario reattach for {peer_name}: {attach_cmd}")
     if mode == "attach":
         subprocess.run(_tmux_command(runtime, "attach-session", "-t", created), check=True)
@@ -3866,6 +3956,9 @@ def _start_noninteractive_ota_smoke(args: argparse.Namespace) -> int:
         )
         if not dry_run:
             time.sleep(12)
+        wait_errors = _ota_wait_for_scenario_applications(target, plan, dry_run=dry_run)
+        if wait_errors:
+            raise RuntimeError("OTA smoke verification failed:\n  - " + "\n  - ".join(wait_errors))
         _ota_start_session_publishers(target, plan, dry_run=dry_run)
         errors += _ota_verify_delivery(target, plan, instance.instance_id, dry_run=dry_run, profile=profile_name)
         errors += _ota_verify_isolation(target, plan, dry_run=dry_run)
@@ -8566,8 +8659,34 @@ TOP_LEVEL_COMMANDS = {
 }
 
 
+def _export_named_resource_paths() -> None:
+    """Put the packaged resource paths in the environment for ros2docker.
+
+    A ros2docker config driven by rosotacom may need to bake a package that
+    lives *inside* the rosotacom install — `com_msgs` above all, since both
+    sides of a link must agree on the message definitions. The install is
+    isolated by design, so the config cannot compute the path and writes
+    `${ROSOTACOM_COM_MSGS}` instead. Something has to put it there, and until
+    now that was every caller's job: a shell snippet each project carried,
+    sourced before every start and stop script.
+
+    That works until the caller is not a shell on the same machine. A two-host
+    OTA run reached the control-centre application on the far side and died with
+    `Could not expand environment variables in host path:
+    '${ROSOTACOM_COM_MSGS}'` — while the identical single-host run passed,
+    because there the peer inherited the variable from the orchestrator's
+    environment. The single-host run could not have caught it by construction.
+
+    rosotacom owns the resource, so rosotacom exports it. `setdefault`, so a
+    caller that deliberately points somewhere else still wins.
+    """
+    for name, path in NAMED_RESOURCES.items():
+        os.environ.setdefault(f"ROSOTACOM_{name.upper()}", str(path))
+
+
 def main(argv: list[str] | None = None) -> int:
     argv = list(sys.argv[1:] if argv is None else argv)
+    _export_named_resource_paths()
     if not argv:
         argv = ["start"]
     elif argv[0] not in TOP_LEVEL_COMMANDS and not argv[0].startswith("-"):

{rosotacom_dev-2.5.dev10 → rosotacom_dev-2.5.dev13}/src/rosotacom_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev10
+Version: 2.5.dev13
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause
@@ -439,7 +439,11 @@ rosotacom ota-smoke 2_native_chatter \
 
 `ota-smoke` accepts sessions and scenarios. It puts rosotacom on each peer,
 stages the active project, runs delivery and isolation checks, collects
-artifacts, stops the run, and removes the remote workdir. Add `--interactive`
+artifacts, stops the run, and removes the remote workdir. For scenario targets
+the checks start only once every declared application container is running
+(bounded at 10 minutes, covering a cold peer's first image build); an
+application that never comes up fails the run by name instead of as missing
+publishers. Add `--interactive`
 for a local control tmux with
 one attachable communication/catmux window per peer with a live status pane below
 each one. Scenario targets also get one native application-container window per

{rosotacom_dev-2.5.dev10 → rosotacom_dev-2.5.dev13}/src/rosotacom_dev.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
   "tag": "2.4",
-  "distance": 10,
-  "node": "gc0c857f77e0a3a0b17134fdc9e0edb7a70f80a1b",
+  "distance": 13,
+  "node": "g4dd300086ea2b30dcaca555da0954cc15a13b103",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-11"

{rosotacom_dev-2.5.dev10 → rosotacom_dev-2.5.dev13}/tests/unit/test_cli.py

@@ -982,6 +982,133 @@ def test_ota_collect_logs_extracts_each_peer_into_instance(
     assert not list(host_dir.glob("**/*.tar.gz.b64"))
 
 
+def _wait_script_env(tmp_path: Path, docker_stdout: str) -> dict[str, str]:
+    """PATH with a stub docker that prints `docker_stdout` for any invocation."""
+    stub = tmp_path / "bin" / "docker"
+    stub.parent.mkdir(exist_ok=True)
+    stub.write_text(f"#!/bin/sh\nprintf '%s\\n' {rosotacom.shlex.quote(docker_stdout)}\n", encoding="utf-8")
+    stub.chmod(0o755)
+    return {**os.environ, "PATH": f"{stub.parent}:{os.environ['PATH']}"}
+
+
+def test_ota_wait_script_is_unbounded_without_timeout() -> None:
+    script = rosotacom._ota_wait_for_running_container_suffix_script("_com_to_b", "a:communication")
+
+    assert "exit 1" not in script
+    assert "waiting for running container:" in script
+
+
+def test_ota_bounded_wait_script_fails_clearly_when_the_bound_is_hit(tmp_path: Path) -> None:
+    script = rosotacom._ota_wait_for_running_container_suffix_script(
+        "_scenario_demo_a_local_app", "a:application:local_app", timeout_s=2
+    )
+
+    result = subprocess.run(
+        ["bash", "-c", script], env=_wait_script_env(tmp_path, "unrelated_container"), text=True, capture_output=True
+    )
+
+    assert result.returncode == 1
+    assert "[ERROR] no running container after 2s: a:application:local_app" in result.stderr
+
+
+def test_ota_bounded_wait_script_succeeds_once_the_container_runs(tmp_path: Path) -> None:
+    script = rosotacom._ota_wait_for_running_container_suffix_script(
+        "_scenario_demo_a_local_app", "a:application:local_app", timeout_s=2
+    )
+    runtime, _resolved = _write_test_scenario_project(tmp_path)
+    container = rosotacom._scenario_container_name(runtime, "demo", "a", "local_app", "run1")
+
+    result = subprocess.run(
+        ["bash", "-c", script], env=_wait_script_env(tmp_path, container), text=True, capture_output=True
+    )
+
+    assert result.returncode == 0
+    assert f"[INFO] found running container: {container}" in result.stdout
+
+
+def test_ota_wait_for_scenario_applications_waits_per_declared_application(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    runtime, _resolved = _write_test_scenario_project(tmp_path)
+    target = rosotacom._resolve_interactive_smoke_target("demo", runtime, "scenario")
+    plan = _ota_plan(tmp_path)
+    ran: list[tuple[str, str]] = []
+
+    def fake_ota_run(peer: rosotacom.OtaSmokePeer, script: str, **_kwargs: object) -> subprocess.CompletedProcess[str]:
+        ran.append((peer.name, script))
+        return subprocess.CompletedProcess([], 0, "", "")
+
+    monkeypatch.setattr(rosotacom, "_ota_run", fake_ota_run)
+
+    assert rosotacom._ota_wait_for_scenario_applications(target, plan, dry_run=False) == []
+
+    assert [name for name, _script in ran] == ["a", "b"]
+    for identity, script in ran:
+        assert f"_scenario_demo_{identity}_local_app" in script
+        # The bound: verification must not wait forever, unlike the interactive panes.
+        assert "exit 1" in script
+
+
+def test_ota_wait_for_scenario_applications_reports_the_bound_not_the_topics(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    runtime, _resolved = _write_test_scenario_project(tmp_path)
+    target = rosotacom._resolve_interactive_smoke_target("demo", runtime, "scenario")
+    plan = _ota_plan(tmp_path)
+
+    monkeypatch.setattr(
+        rosotacom,
+        "_ota_run",
+        lambda peer, script, **kwargs: subprocess.CompletedProcess([], 0 if peer.name == "a" else 1, "", ""),
+    )
+
+    errors = rosotacom._ota_wait_for_scenario_applications(target, plan, dry_run=False)
+
+    assert len(errors) == 1
+    assert "b: application 'local_app' has no running container" in errors[0]
+    assert "never came up" in errors[0]
+
+
+def test_ota_verify_only_stops_before_checks_when_applications_never_come_up(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    runtime, _resolved = _write_test_scenario_project(tmp_path)
+    target = rosotacom._resolve_interactive_smoke_target("demo", runtime, "scenario")
+    plan = _ota_plan(tmp_path)
+    checks: list[str] = []
+
+    monkeypatch.setattr(rosotacom, "_resolve_ota_smoke_context", lambda args: (runtime, plan, target))
+    monkeypatch.setattr(
+        rosotacom,
+        "_ota_wait_for_scenario_applications",
+        lambda *args, **kwargs: ["b: application 'local_app' has no running container after 600s"],
+    )
+    monkeypatch.setattr(rosotacom, "_ota_start_session_publishers", lambda *args, **kwargs: checks.append("publishers"))
+    monkeypatch.setattr(rosotacom, "_ota_verify_delivery", lambda *args, **kwargs: checks.append("delivery") or [])
+    monkeypatch.setattr(rosotacom, "_ota_verify_isolation", lambda *args, **kwargs: checks.append("isolation") or [])
+
+    rc = rosotacom._ota_verify_only(argparse.Namespace(instance_id="run1", dry_run=False))
+
+    assert rc == 1
+    # The point of #218: no status checks against a scenario that is not up.
+    assert checks == []
+
+
+def test_ota_wait_for_scenario_applications_ignores_session_targets(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    runtime, _resolved = _write_test_scenario_project(tmp_path)
+    target = rosotacom._resolve_interactive_smoke_target("demo", runtime, "session")
+    plan = _ota_plan(tmp_path)
+    monkeypatch.setattr(rosotacom, "_ota_run", lambda *args, **kwargs: pytest.fail("session targets must not wait"))
+
+    assert rosotacom._ota_wait_for_scenario_applications(target, plan, dry_run=False) == []
+
+
 def test_ota_smoke_parser_accepts_stop_without_peer_arguments(monkeypatch: pytest.MonkeyPatch) -> None:
     calls: list[argparse.Namespace] = []
     monkeypatch.setattr(rosotacom, "ota_smoke", lambda args: calls.append(args) or 0)
@@ -1076,6 +1203,9 @@ def test_noninteractive_ota_smoke_lifecycle_uses_generic_runner(
     monkeypatch.setattr(rosotacom, "_ota_preflight", lambda *args, **kwargs: calls.append("preflight"))
     monkeypatch.setattr(rosotacom, "_ota_prepare_hosts", lambda *args, **kwargs: calls.append("prepare"))
     monkeypatch.setattr(rosotacom, "_ota_start_peers", lambda *args, **kwargs: calls.append("start"))
+    monkeypatch.setattr(
+        rosotacom, "_ota_wait_for_scenario_applications", lambda *args, **kwargs: calls.append("wait-apps") or []
+    )
     monkeypatch.setattr(rosotacom, "_ota_start_session_publishers", lambda *args, **kwargs: calls.append("publishers"))
     monkeypatch.setattr(rosotacom, "_ota_verify_delivery", lambda *args, **kwargs: calls.append("test") or [])
     monkeypatch.setattr(rosotacom, "_ota_verify_isolation", lambda *args, **kwargs: calls.append("isolation") or [])
@@ -1104,6 +1234,7 @@ def test_noninteractive_ota_smoke_lifecycle_uses_generic_runner(
         "prepare",
         "start",
         "sleep:12",
+        "wait-apps",
         "publishers",
         "test",
         "isolation",
@@ -1161,6 +1292,8 @@ def test_ota_smoke_dry_run_exercises_generic_remote_flow(
     assert "b: reachable: running remote command" in out
     assert "a: start demo: running remote command" in out
     assert "b: start demo: running remote command" in out
+    assert "a: wait for application local_app: running remote command" in out
+    assert "b: wait for application local_app: running remote command" in out
     assert "a: rosotacom test: running remote command" in out
     assert "a: publish isolation probe: running remote command" in out
     assert "b: check isolation probe absent: running remote command" in out
@@ -3231,6 +3364,37 @@ def _ota_exec_plan(project_config: Path, command: str = "remote-rosotacom majest
     )
 
 
+def test_named_resources_reach_ros2docker_through_the_environment(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # A ros2docker config cannot compute a path into an isolated install, so it
+    # writes ${ROSOTACOM_COM_MSGS}. Until this, every caller had to export that
+    # itself -- which works right up to the point where the caller is not a
+    # shell on the same machine. A two-host run died on the far side with
+    # "Could not expand environment variables in host path" while the identical
+    # single-host run passed, because there the peer inherited the variable from
+    # the orchestrator. The single-host run could not have caught it.
+    for name in rosotacom.NAMED_RESOURCES:
+        monkeypatch.delenv(f"ROSOTACOM_{name.upper()}", raising=False)
+
+    rosotacom._export_named_resource_paths()
+
+    assert os.environ["ROSOTACOM_COM_MSGS"] == str(rosotacom.NAMED_RESOURCES["com_msgs"])
+    assert Path(os.environ["ROSOTACOM_COM_MSGS"]).name == "com_msgs"
+
+
+def test_an_explicit_resource_path_is_not_overridden(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # setdefault, not assignment: a caller pointing somewhere else on purpose --
+    # a checkout under development, say -- still wins.
+    monkeypatch.setenv("ROSOTACOM_COM_MSGS", "/somewhere/else")
+
+    rosotacom._export_named_resource_paths()
+
+    assert os.environ["ROSOTACOM_COM_MSGS"] == "/somewhere/else"
+
+
 def test_ota_peer_exec_replaces_the_ssh_client(tmp_path: Path) -> None:
     # The point of the flag: a peer can be reached by something that is not a
     # shell. The script arrives as the final argument, which is the contract
@@ -3245,19 +3409,49 @@ def test_ota_peer_exec_replaces_the_ssh_client(tmp_path: Path) -> None:
     ]
 
 
-def test_ota_peer_exec_ignores_options_that_belong_to_ssh(tmp_path: Path) -> None:
-    # `-t` and `-o BatchMode=yes` are options of one client. Passing them to an
-    # arbitrary transport would be guessing at an interface it never agreed to,
-    # and the failure would look like a broken peer rather than a wrong flag.
+def test_ota_peer_exec_ignores_batch_mode_which_belongs_to_ssh(tmp_path: Path) -> None:
+    # `-o BatchMode=yes` is an option of one client. Passing it to an arbitrary
+    # transport would be guessing at an interface it never agreed to, and the
+    # failure would look like a broken peer rather than a wrong flag.
     plan = _ota_exec_plan(_write_checkout_project(tmp_path))
 
-    assert rosotacom._ota_remote_argv(plan.peers["a"], "true", tty=True, batch=True) == [
+    assert rosotacom._ota_remote_argv(plan.peers["a"], "true", batch=True) == [
         "remote-rosotacom",
         "majestic-tks",
         "true",
     ]
 
 
+def test_ota_peer_exec_carries_the_tty_request(tmp_path: Path) -> None:
+    # Dropping this cost a two-host run: the peer windows start their container
+    # with `docker run -i -t`, which refuses outright when the far side has no
+    # terminal, so a transport that cannot be told "this one is interactive"
+    # carries the probes and not the experiment.
+    plan = _ota_exec_plan(_write_checkout_project(tmp_path))
+
+    assert rosotacom._ota_remote_argv(plan.peers["a"], "true", tty=True) == [
+        "env",
+        "ROSOTACOM_PEER_TTY=1",
+        "remote-rosotacom",
+        "majestic-tks",
+        "true",
+    ]
+
+
+def test_ota_peer_exec_tty_is_a_variable_so_an_older_transport_still_works(
+    tmp_path: Path,
+) -> None:
+    # An environment variable rather than a flag, so a transport that does not
+    # understand it behaves exactly as before instead of dying on an argument it
+    # never agreed to parse. The argv contract is what makes any command usable
+    # as a transport at all.
+    plan = _ota_exec_plan(_write_checkout_project(tmp_path))
+    argv = rosotacom._ota_remote_argv(plan.peers["a"], "true", tty=True)
+
+    assert argv[-1] == "true"
+    assert not any(part.startswith("-") for part in argv)
+
+
 def test_ota_peer_exec_makes_a_peer_remote(tmp_path: Path) -> None:
     # Everything that used to ask `peer.ssh` meant "is it over there". A peer
     # behind a command transport is, and a caller that still reads `.ssh` would