@@ -108,21 +108,43 @@ def get_binary_path(target: str) -> Path:
     return _resolve_target_path(target)
 
 
-def _pgrep_cmdline_pattern(binary_path: str) -> str:
+def pgrep_cmdline_pattern(binary_path: str) -> str:
     """Build POSIX ERE pattern matching binary with optional arguments."""
     return rf"^{re.escape(binary_path)}([[:space:]]|$)"
 
 
-def _is_running(binary_path: Path) -> bool:
+def is_running(binary_path: str | Path) -> bool:
     result = subprocess.run(
-        ["pgrep", "-f", _pgrep_cmdline_pattern(str(binary_path))],
+        ["pgrep", "-f", pgrep_cmdline_pattern(str(binary_path))],
         capture_output=True,
         text=True,
         check=False,
     )
     return result.returncode == 0
 
 
+def first_pid(binary_path: str | Path) -> str | None:
+    result = subprocess.run(
+        ["pgrep", "-f", pgrep_cmdline_pattern(str(binary_path))],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        return None
+    lines = [line for line in result.stdout.splitlines() if line]
+    return lines[0] if lines else None
+
+
+def wait_until(predicate, timeout_s: float, interval_s: float = 0.2) -> bool:
+    deadline = time.time() + timeout_s
+    while time.time() < deadline:
+        if predicate():
+            return True
+        time.sleep(interval_s)
+    return False
+
+
 _SETCAP_CAPS = "cap_setuid,cap_setgid,cap_sys_nice+ep"
 
 
@@ -220,12 +242,39 @@ def _grant_sandbox_capabilities(binary_path: Path) -> tuple[bool, str]:
 
 
 def _wait_for_apps(apps: dict[str, Path], timeout_s: float = 8.0, interval_s: float = 0.2) -> bool:
+    return wait_until(lambda: all(is_running(path) for path in apps.values()), timeout_s, interval_s)
+
+
+_RUNTIME_ROOT_LOCK_PATH = Path("/tmp/lifecycle_fit.lock")
+_RUNTIME_ROOT_LOCK_TIMEOUT_S = 120.0
+
+
+def _acquire_runtime_root_lock(timeout_s: float = _RUNTIME_ROOT_LOCK_TIMEOUT_S):
+    """Acquire the exclusive lock guarding the shared /tmp/lifecycle_fit runtime_root.
+
+    Polls with a non-blocking flock instead of blocking indefinitely: an unbounded
+    `LOCK_EX` would hang forever (and silently eat the whole CI job's timeout budget)
+    if the lock is ever legitimately held longer than expected, giving no diagnostic
+    signal about what's actually stuck. No lifecycle test suite should need this lock
+    for anywhere near `timeout_s`, so failing loudly here is strictly more useful than
+    an indefinite wait.
+    """
+    lock_file = _RUNTIME_ROOT_LOCK_PATH.open("w", encoding="utf-8")
     deadline = time.time() + timeout_s
-    while time.time() < deadline:
-        if all(_is_running(path) for path in apps.values()):
-            return True
-        time.sleep(interval_s)
-    return False
+    while True:
+        try:
+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+            return lock_file
+        except OSError:
+            if time.time() >= deadline:
+                lock_file.close()
+                raise RuntimeError(
+                    f"Could not acquire {_RUNTIME_ROOT_LOCK_PATH} within {timeout_s}s; "
+                    "another lifecycle daemon run appears to be holding it. If no other "
+                    "lifecycle test is genuinely running, a stale process may be stuck "
+                    "holding this lock."
+                ) from None
+            time.sleep(0.5)
 
 
 @dataclass
@@ -276,8 +325,7 @@ def start_launch_manager_daemon(
     instance here rather than the shared `launch_manager_daemon` fixture.
     """
 
-    lock_file = Path("/tmp/lifecycle_fit.lock").open("w", encoding="utf-8")
-    fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+    lock_file = _acquire_runtime_root_lock()
 
     work_dir = tmp_path_factory.mktemp("lm-daemon")
     etc_dir = work_dir / "etc"
 
@@ -18,52 +18,49 @@
 """
 
 import json
-import re
-import subprocess
-import time
 from pathlib import Path
 from typing import Any
 
 import pytest
-from daemon_helpers import launch_manager_daemon, start_launch_manager_daemon, stop_launch_manager_daemon
+from daemon_helpers import (
+    first_pid,
+    is_running,
+    launch_manager_daemon,
+    start_launch_manager_daemon,
+    stop_launch_manager_daemon,
+    wait_until,
+)
 from test_properties import add_test_properties
 
-pytestmark = [
-    pytest.mark.daemon,
-    pytest.mark.parametrize("version", ["rust", "cpp"], scope="class"),
-]
+pytestmark = [pytest.mark.daemon]
 
 
+@pytest.mark.parametrize("version", ["rust", "cpp"], scope="class")
 class TestConditionalLaunchingWithDaemon:
     """Verify dependency-based conditional launching with real daemon behavior."""
 
-    @staticmethod
-    def _pgrep_cmdline_pattern(binary_path: str) -> str:
-        """Build POSIX ERE pattern matching binary with optional arguments."""
-        return rf"^{re.escape(binary_path)}([[:space:]]|$)"
+    @add_test_properties(
+        partially_verifies=["feat_req__lifecycle__launch_support"],
+        test_type="requirements-based",
+        derivation_technique="requirements-analysis",
+    )
+    def test_startup_launches_conditioned_processes(self, launch_manager_daemon: dict[str, Any], version: str) -> None:
+        """Verify supervised processes are launched as part of conditional startup."""
+        daemon_info = launch_manager_daemon
+        app_name = "rust_supervised_app" if version == "rust" else "cpp_supervised_app"
+        app_path = str(daemon_info["apps"][version])
 
-    @staticmethod
-    def _is_running(binary_path: str) -> bool:
-        result = subprocess.run(
-            ["pgrep", "-f", TestConditionalLaunchingWithDaemon._pgrep_cmdline_pattern(binary_path)],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        return result.returncode == 0
+        started = wait_until(lambda: is_running(app_path), timeout_s=8.0)
+        assert started, f"{app_name} was not launched in conditional startup"
 
-    @staticmethod
-    def _first_pid(binary_path: str) -> str | None:
-        result = subprocess.run(
-            ["pgrep", "-f", TestConditionalLaunchingWithDaemon._pgrep_cmdline_pattern(binary_path)],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        if result.returncode != 0:
-            return None
-        lines = [line for line in result.stdout.splitlines() if line]
-        return lines[0] if lines else None
+
+class TestConditionalLaunchingDependencyOrdering:
+    """Verify cpp-before-rust ordering and its declaration in config.
+
+    Not parametrized on `version`: both tests inspect the fixed cpp/rust pair
+    (or the static config) regardless of which scenario variant is under test
+    elsewhere, so parametrizing here would only re-run identical assertions.
+    """
 
     @staticmethod
     def _proc_start_ticks(pid: str) -> int | None:
@@ -78,29 +75,6 @@ def _proc_start_ticks(pid: str) -> int | None:
         except ValueError:
             return None
 
-    @staticmethod
-    def _wait_until(predicate, timeout_s: float, interval_s: float = 0.2) -> bool:
-        deadline = time.time() + timeout_s
-        while time.time() < deadline:
-            if predicate():
-                return True
-            time.sleep(interval_s)
-        return False
-
-    @add_test_properties(
-        partially_verifies=["feat_req__lifecycle__launch_support"],
-        test_type="requirements-based",
-        derivation_technique="requirements-analysis",
-    )
-    def test_startup_launches_conditioned_processes(self, launch_manager_daemon: dict[str, Any], version: str) -> None:
-        """Verify supervised processes are launched as part of conditional startup."""
-        daemon_info = launch_manager_daemon
-        app_name = "rust_supervised_app" if version == "rust" else "cpp_supervised_app"
-        app_path = str(daemon_info["apps"][version])
-
-        started = self._wait_until(lambda: self._is_running(app_path), timeout_s=8.0)
-        assert started, f"{app_name} was not launched in conditional startup"
-
     @add_test_properties(
         partially_verifies=[
             "feat_req__lifecycle__process_ordering",
@@ -112,21 +86,20 @@ def test_startup_launches_conditioned_processes(self, launch_manager_daemon: dic
     def test_rust_launch_is_conditioned_on_cpp_dependency(
         self,
         launch_manager_daemon: dict[str, Any],
-        version: str,
     ) -> None:
         """Verify rust app starts no earlier than its configured C++ dependency."""
         daemon_info = launch_manager_daemon
         cpp_path = str(daemon_info["apps"]["cpp"])
         rust_path = str(daemon_info["apps"]["rust"])
 
-        started = self._wait_until(
-            lambda: self._is_running(cpp_path) and self._is_running(rust_path),
+        started = wait_until(
+            lambda: is_running(cpp_path) and is_running(rust_path),
             timeout_s=8.0,
         )
         assert started, "cpp_supervised_app and rust_supervised_app should both be running"
 
-        cpp_pid = self._first_pid(cpp_path)
-        rust_pid = self._first_pid(rust_path)
+        cpp_pid = first_pid(cpp_path)
+        rust_pid = first_pid(rust_path)
         assert cpp_pid is not None, "Could not resolve PID for cpp_supervised_app"
         assert rust_pid is not None, "Could not resolve PID for rust_supervised_app"
 
@@ -144,11 +117,7 @@ def test_rust_launch_is_conditioned_on_cpp_dependency(
         test_type="requirements-based",
         derivation_technique="requirements-analysis",
     )
-    def test_dependency_is_declared_in_lifecycle_config(
-        self,
-        launch_manager_daemon: dict[str, Any],
-        version: str,
-    ) -> None:
+    def test_dependency_is_declared_in_lifecycle_config(self, launch_manager_daemon: dict[str, Any]) -> None:
         """Verify runtime configuration defines rust conditional dependency on cpp."""
         config_path = Path(__file__).resolve().parents[3] / "configs" / "lifecycle_daemon_config.json"
         config = json.loads(config_path.read_text(encoding="utf-8"))
@@ -160,7 +129,6 @@ def test_dependency_is_declared_in_lifecycle_config(
         )
 
 
-@pytest.mark.daemon
 class TestConditionalLaunchingBlocksOnMissingDependency:
     """Verify rust startup is actually gated on cpp, not merely correlated with it.
 
@@ -170,30 +138,10 @@ class TestConditionalLaunchingBlocksOnMissingDependency:
     Safe to run its own daemon here because the bazel targets for these tests
     are tagged tags = ["exclusive"], guaranteeing no other lifecycle daemon is
     using the shared runtime_root/lock at the same time.
-    """
 
-    @staticmethod
-    def _pgrep_cmdline_pattern(binary_path: str) -> str:
-        return rf"^{re.escape(binary_path)}([[:space:]]|$)"
-
-    @classmethod
-    def _is_running(cls, binary_path: str) -> bool:
-        result = subprocess.run(
-            ["pgrep", "-f", cls._pgrep_cmdline_pattern(binary_path)],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        return result.returncode == 0
-
-    @staticmethod
-    def _wait_until(predicate, timeout_s: float, interval_s: float = 0.2) -> bool:
-        deadline = time.time() + timeout_s
-        while time.time() < deadline:
-            if predicate():
-                return True
-            time.sleep(interval_s)
-        return False
+    Not parametrized on `version`: dependency gating is independent of which
+    scenario variant is under test elsewhere, so this runs exactly once.
+    """
 
     @add_test_properties(
         partially_verifies=[
@@ -205,12 +153,9 @@ def _wait_until(predicate, timeout_s: float, interval_s: float = 0.2) -> bool:
         derivation_technique="requirements-analysis",
     )
     def test_rust_stays_down_until_cpp_dependency_becomes_available(
-        self, tmp_path_factory: pytest.TempPathFactory, version: str
+        self, tmp_path_factory: pytest.TempPathFactory
     ) -> None:
         """Verify rust does not start while cpp is withheld, and does once cpp is unblocked."""
-        if version != "rust":
-            pytest.skip("dependency-gating check is independent of the 'version' axis; runs once")
-
         daemon_info = start_launch_manager_daemon(
             tmp_path_factory,
             blocked_apps=frozenset({"cpp"}),
@@ -221,15 +166,15 @@ def test_rust_stays_down_until_cpp_dependency_becomes_available(
             rust_path = str(daemon_info["apps"]["rust"])
 
             # cpp cannot execute (mode 0o000): rust must not appear while it's withheld.
-            rust_started_early = self._wait_until(lambda: self._is_running(rust_path), timeout_s=4.0)
+            rust_started_early = wait_until(lambda: is_running(rust_path), timeout_s=4.0)
             assert not rust_started_early, (
                 "rust_supervised_app started even though its cpp_supervised_app dependency "
                 "was withheld (non-executable); dependency gating was not enforced"
             )
 
             # Unblock cpp: rust should now be allowed to start.
             cpp_path.chmod(0o755)
-            rust_started = self._wait_until(lambda: self._is_running(rust_path), timeout_s=8.0)
+            rust_started = wait_until(lambda: is_running(rust_path), timeout_s=8.0)
             assert rust_started, (
                 "rust_supervised_app did not start after its cpp_supervised_app dependency became available"
             )
 
@@ -333,3 +333,65 @@ def test_unsupported_prefix_is_rejected_immediately(
             f"Rejection took {elapsed_s:.2f}s, close to the full {self._TIMEOUT_MS}ms timeout - "
             "the prefix should be validated up front, not discovered by waiting it out."
         )
+
+
+@add_test_properties(
+    partially_verifies=["feat_req__lifecycle__validate_conditions"],
+    test_type="requirements-based",
+    derivation_technique="requirements-analysis",
+)
+class TestConditionalLaunchingScenarioRejectsEmptyConditions(LifecycleScenario):
+    """Verify an empty wait_conditions list is rejected as invalid configuration up front,
+    distinct from a legitimate condition that simply times out unmet.
+
+    Without this, a future refactor of parse_wait_conditions/parse_string_array_field could
+    silently start treating an empty list as "nothing to wait for, immediate success" instead
+    of a configuration error - a regression this test would otherwise be the only thing to
+    catch, since the happy-path and unsupported-prefix tests never exercise this branch.
+    """
+
+    @pytest.fixture(scope="class")
+    def scenario_name(self) -> str:
+        return "lifecycle.conditional_launching"
+
+    _TIMEOUT_MS = 2000
+
+    @pytest.fixture(scope="class")
+    def test_config(self) -> dict[str, Any]:
+        return {
+            "test": {
+                "wait_conditions": [],
+                "polling_interval_ms": 20,
+                "timeout_ms": self._TIMEOUT_MS,
+            },
+        }
+
+    def expect_command_failure(self) -> bool:
+        return True
+
+    def capture_stderr(self) -> bool:
+        return True
+
+    def test_empty_conditions_are_rejected_immediately(
+        self,
+        command: list[str],
+        execution_timeout: float,
+        version: str,
+    ) -> None:
+        """Verify validation rejects an empty wait_conditions list outright, before entering
+        the wait loop, rather than only surfacing the same error after the full timeout."""
+        start = time.monotonic()
+        result = self._run_command(command, execution_timeout)
+        elapsed_s = time.monotonic() - start
+
+        assert result.return_code != ResultCode.SUCCESS, (
+            f"Expected failure for an empty wait_conditions list, got: {result}"
+        )
+        assert result.stderr is not None
+        assert "Wait conditions were not provided" in result.stderr, (
+            f"Expected a missing/empty wait_conditions validation error on stderr, got: {result.stderr}"
+        )
+        assert elapsed_s < (self._TIMEOUT_MS / 1000) / 2, (
+            f"Rejection took {elapsed_s:.2f}s, close to the full {self._TIMEOUT_MS}ms timeout - "
+            "an empty condition list should be validated up front, not discovered by waiting it out."
+        )