diff --git a/launch/tier4_control_launch/launch/control.main.mrm-v0.6.tmp.launch.py b/launch/tier4_control_launch/launch/control.main.mrm-v0.6.tmp.launch.py
new file mode 100644
index 0000000000000..47c27244d9cb7
--- /dev/null
+++ b/launch/tier4_control_launch/launch/control.main.mrm-v0.6.tmp.launch.py
@@ -0,0 +1,431 @@
+# Copyright 2020 Tier IV, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import launch
+from launch.actions import DeclareLaunchArgument
+from launch.actions import GroupAction
+from launch.actions import IncludeLaunchDescription
+from launch.actions import OpaqueFunction
+from launch.actions import SetLaunchConfiguration
+from launch.conditions import IfCondition
+from launch.conditions import UnlessCondition
+from launch.launch_description_sources import PythonLaunchDescriptionSource
+from launch.substitutions import LaunchConfiguration
+from launch_ros.actions import ComposableNodeContainer
+from launch_ros.actions import LoadComposableNodes
+from launch_ros.actions import PushRosNamespace
+from launch_ros.descriptions import ComposableNode
+from launch_ros.substitutions import FindPackageShare
+import yaml
+
+
+def launch_setup(context, *args, **kwargs):
+    with open(LaunchConfiguration("vehicle_param_file").perform(context), "r") as f:
+        vehicle_info_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+
+    with open(LaunchConfiguration("nearest_search_param_path").perform(context), "r") as f:
+        nearest_search_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+
+    with open(
+        LaunchConfiguration("trajectory_follower_node_param_path").perform(context), "r"
+    ) as f:
+        trajectory_follower_node_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+    with open(LaunchConfiguration("lat_controller_param_path").perform(context), "r") as f:
+        lat_controller_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+    with open(LaunchConfiguration("lon_controller_param_path").perform(context), "r") as f:
+        lon_controller_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+    with open(LaunchConfiguration("vehicle_cmd_gate_param_path").perform(context), "r") as f:
+        vehicle_cmd_gate_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+    with open(LaunchConfiguration("lane_departure_checker_param_path").perform(context), "r") as f:
+        lane_departure_checker_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+    with open(LaunchConfiguration("control_validator_param_path").perform(context), "r") as f:
+        control_validator_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+    with open(
+        LaunchConfiguration("operation_mode_transition_manager_param_path").perform(context), "r"
+    ) as f:
+        operation_mode_transition_manager_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+    with open(LaunchConfiguration("shift_decider_param_path").perform(context), "r") as f:
+        shift_decider_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+    with open(
+        LaunchConfiguration("obstacle_collision_checker_param_path").perform(context), "r"
+    ) as f:
+        obstacle_collision_checker_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+    with open(LaunchConfiguration("aeb_param_path").perform(context), "r") as f:
+        aeb_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+    with open(LaunchConfiguration("predicted_path_checker_param_path").perform(context), "r") as f:
+        predicted_path_checker_param = yaml.safe_load(f)["/**"]["ros__parameters"]
+
+    controller_component = ComposableNode(
+        package="trajectory_follower_node",
+        plugin="autoware::motion::control::trajectory_follower_node::Controller",
+        name="controller_node_exe",
+        namespace="trajectory_follower",
+        remappings=[
+            ("~/input/reference_trajectory", "/planning/scenario_planning/trajectory"),
+            ("~/input/current_odometry", "/localization/kinematic_state"),
+            ("~/input/current_steering", "/vehicle/status/steering_status"),
+            ("~/input/current_accel", "/localization/acceleration"),
+            ("~/input/current_operation_mode", "/system/operation_mode/state"),
+            ("~/output/predicted_trajectory", "lateral/predicted_trajectory"),
+            ("~/output/lateral_diagnostic", "lateral/diagnostic"),
+            ("~/output/slope_angle", "longitudinal/slope_angle"),
+            ("~/output/longitudinal_diagnostic", "longitudinal/diagnostic"),
+            ("~/output/control_cmd", "control_cmd"),
+        ],
+        parameters=[
+            {
+                "lateral_controller_mode": LaunchConfiguration("lateral_controller_mode"),
+                "longitudinal_controller_mode": LaunchConfiguration("longitudinal_controller_mode"),
+            },
+            nearest_search_param,
+            trajectory_follower_node_param,
+            lon_controller_param,
+            lat_controller_param,
+            vehicle_info_param,
+        ],
+        extra_arguments=[{"use_intra_process_comms": LaunchConfiguration("use_intra_process")}],
+    )
+
+    # lane departure checker
+    lane_departure_component = ComposableNode(
+        package="lane_departure_checker",
+        plugin="lane_departure_checker::LaneDepartureCheckerNode",
+        name="lane_departure_checker_node",
+        namespace="trajectory_follower",
+        remappings=[
+            ("~/input/odometry", "/localization/kinematic_state"),
+            ("~/input/lanelet_map_bin", "/map/vector_map"),
+            ("~/input/route", "/planning/mission_planning/route"),
+            ("~/input/reference_trajectory", "/planning/scenario_planning/trajectory"),
+            (
+                "~/input/predicted_trajectory",
+                "/control/trajectory_follower/lateral/predicted_trajectory",
+            ),
+        ],
+        parameters=[nearest_search_param, lane_departure_checker_param, vehicle_info_param],
+        extra_arguments=[{"use_intra_process_comms": LaunchConfiguration("use_intra_process")}],
+    )
+    # control validator checker
+    control_validator_component = ComposableNode(
+        package="control_validator",
+        plugin="control_validator::ControlValidator",
+        name="control_validator",
+        remappings=[
+            ("~/input/kinematics", "/localization/kinematic_state"),
+            ("~/input/reference_trajectory", "/planning/scenario_planning/trajectory"),
+            (
+                "~/input/predicted_trajectory",
+                "/control/trajectory_follower/lateral/predicted_trajectory",
+            ),
+            ("~/output/validation_status", "~/validation_status"),
+        ],
+        parameters=[control_validator_param],
+        extra_arguments=[{"use_intra_process_comms": LaunchConfiguration("use_intra_process")}],
+    )
+
+    # shift decider
+    shift_decider_component = ComposableNode(
+        package="shift_decider",
+        plugin="ShiftDecider",
+        name="shift_decider",
+        remappings=[
+            ("input/control_cmd", "/control/trajectory_follower/control_cmd"),
+            ("input/state", "/autoware/state"),
+            ("input/current_gear", "/vehicle/status/gear_status"),
+            ("output/gear_cmd", "/control/shift_decider/gear_cmd"),
+        ],
+        parameters=[
+            shift_decider_param,
+        ],
+        extra_arguments=[{"use_intra_process_comms": LaunchConfiguration("use_intra_process")}],
+    )
+
+    # autonomous emergency braking
+    autonomous_emergency_braking = ComposableNode(
+        package="autonomous_emergency_braking",
+        plugin="autoware::motion::control::autonomous_emergency_braking::AEB",
+        name="autonomous_emergency_braking",
+        remappings=[
+            ("~/input/pointcloud", "/perception/obstacle_segmentation/pointcloud"),
+            ("~/input/velocity", "/vehicle/status/velocity_status"),
+            ("~/input/imu", "/sensing/imu/imu_data"),
+            ("~/input/odometry", "/localization/kinematic_state"),
+            (
+                "~/input/predicted_trajectory",
+                "/control/trajectory_follower/lateral/predicted_trajectory",
+            ),
+        ],
+        parameters=[
+            aeb_param,
+        ],
+        extra_arguments=[{"use_intra_process_comms": LaunchConfiguration("use_intra_process")}],
+    )
+
+    autonomous_emergency_braking_loader = LoadComposableNodes(
+        condition=IfCondition(LaunchConfiguration("enable_autonomous_emergency_braking")),
+        composable_node_descriptions=[autonomous_emergency_braking],
+        target_container="/control/control_container",
+    )
+
+    # autonomous emergency braking
+    predicted_path_checker = ComposableNode(
+        package="predicted_path_checker",
+        plugin="autoware::motion::control::predicted_path_checker::PredictedPathCheckerNode",
+        name="predicted_path_checker",
+        remappings=[
+            ("~/input/objects", "/perception/object_recognition/objects"),
+            ("~/input/reference_trajectory", "/planning/scenario_planning/trajectory"),
+            ("~/input/current_accel", "/localization/acceleration"),
+            ("~/input/odometry", "/localization/kinematic_state"),
+            (
+                "~/input/predicted_trajectory",
+                "/control/trajectory_follower/lateral/predicted_trajectory",
+            ),
+        ],
+        parameters=[
+            vehicle_info_param,
+            predicted_path_checker_param,
+        ],
+        extra_arguments=[{"use_intra_process_comms": LaunchConfiguration("use_intra_process")}],
+    )
+
+    predicted_path_checker_loader = LoadComposableNodes(
+        condition=IfCondition(LaunchConfiguration("enable_predicted_path_checker")),
+        composable_node_descriptions=[predicted_path_checker],
+        target_container="/control/control_container",
+    )
+
+    # vehicle cmd gate
+    vehicle_cmd_gate_component = ComposableNode(
+        package="vehicle_cmd_gate",
+        plugin="vehicle_cmd_gate::VehicleCmdGate",
+        name="vehicle_cmd_gate",
+        remappings=[
+            ("input/steering", "/vehicle/status/steering_status"),
+            ("input/operation_mode", "/system/operation_mode/state"),
+            ("input/auto/control_cmd", "/control/trajectory_follower/control_cmd"),
+            ("input/auto/turn_indicators_cmd", "/planning/turn_indicators_cmd"),
+            ("input/auto/hazard_lights_cmd", "/planning/hazard_lights_cmd"),
+            ("input/auto/gear_cmd", "/control/shift_decider/gear_cmd"),
+            ("input/external/control_cmd", "/external/selected/control_cmd"),
+            ("input/external/turn_indicators_cmd", "/external/selected/turn_indicators_cmd"),
+            ("input/external/hazard_lights_cmd", "/external/selected/hazard_lights_cmd"),
+            ("input/external/gear_cmd", "/external/selected/gear_cmd"),
+            ("input/external_emergency_stop_heartbeat", "/external/selected/heartbeat"),
+            ("input/gate_mode", "/control/gate_mode_cmd"),
+            ("input/emergency/control_cmd", "/system/emergency/control_cmd"),
+            ("input/emergency/hazard_lights_cmd", "/system/emergency/hazard_lights_cmd"),
+            ("input/emergency/gear_cmd", "/system/emergency/gear_cmd"),
+            ("input/mrm_state", "/system/fail_safe/mrm_state"),
+            ("input/kinematics", "/localization/kinematic_state"),
+            ("input/acceleration", "/localization/acceleration"),
+            ("output/vehicle_cmd_emergency", "/control/command/emergency_cmd"),
+            ("output/control_cmd", "/main/control/command/control_cmd"),
+            ("output/gear_cmd", "/control/command/gear_cmd"),
+            ("output/turn_indicators_cmd", "/control/command/turn_indicators_cmd"),
+            ("output/hazard_lights_cmd", "/control/command/hazard_lights_cmd"),
+            ("output/gate_mode", "/control/current_gate_mode"),
+            ("output/engage", "/api/autoware/get/engage"),
+            ("output/external_emergency", "/api/autoware/get/emergency"),
+            ("output/operation_mode", "/control/vehicle_cmd_gate/operation_mode"),
+            ("~/service/engage", "/api/autoware/set/engage"),
+            ("~/service/external_emergency", "/api/autoware/set/emergency"),
+            # TODO(Takagi, Isamu): deprecated
+            ("input/engage", "/autoware/engage"),
+            ("~/service/external_emergency_stop", "~/external_emergency_stop"),
+            ("~/service/clear_external_emergency_stop", "~/clear_external_emergency_stop"),
+        ],
+        parameters=[
+            vehicle_cmd_gate_param,
+            vehicle_info_param,
+            {
+                "check_external_emergency_heartbeat": LaunchConfiguration(
+                    "check_external_emergency_heartbeat"
+                ),
+            },
+        ],
+        extra_arguments=[{"use_intra_process_comms": LaunchConfiguration("use_intra_process")}],
+    )
+
+    # operation mode transition manager
+    operation_mode_transition_manager_component = ComposableNode(
+        package="operation_mode_transition_manager",
+        plugin="operation_mode_transition_manager::OperationModeTransitionManager",
+        name="operation_mode_transition_manager",
+        remappings=[
+            # input
+            ("kinematics", "/localization/kinematic_state"),
+            ("steering", "/vehicle/status/steering_status"),
+            ("trajectory", "/planning/scenario_planning/trajectory"),
+            ("control_cmd", "/control/command/control_cmd"),
+            ("trajectory_follower_control_cmd", "/control/trajectory_follower/control_cmd"),
+            ("control_mode_report", "/vehicle/status/control_mode"),
+            ("gate_operation_mode", "/control/vehicle_cmd_gate/operation_mode"),
+            # output
+            ("is_autonomous_available", "/control/is_autonomous_available"),
+            ("control_mode_request", "/control/control_mode_request"),
+        ],
+        parameters=[
+            nearest_search_param,
+            operation_mode_transition_manager_param,
+            vehicle_info_param,
+        ],
+    )
+
+    # external cmd selector
+    external_cmd_selector_loader = IncludeLaunchDescription(
+        PythonLaunchDescriptionSource(
+            [FindPackageShare("external_cmd_selector"), "/launch/external_cmd_selector.launch.py"]
+        ),
+        launch_arguments=[
+            ("use_intra_process", LaunchConfiguration("use_intra_process")),
+            ("target_container", "/control/control_container"),
+            (
+                "external_cmd_selector_param_path",
+                LaunchConfiguration("external_cmd_selector_param_path"),
+            ),
+        ],
+    )
+
+    # external cmd converter
+    external_cmd_converter_loader = IncludeLaunchDescription(
+        PythonLaunchDescriptionSource(
+            [FindPackageShare("external_cmd_converter"), "/launch/external_cmd_converter.launch.py"]
+        ),
+        launch_arguments=[
+            ("use_intra_process", LaunchConfiguration("use_intra_process")),
+            ("target_container", "/control/control_container"),
+        ],
+    )
+
+    # obstacle collision checker
+    obstacle_collision_checker_component = ComposableNode(
+        package="obstacle_collision_checker",
+        plugin="obstacle_collision_checker::ObstacleCollisionCheckerNode",
+        name="obstacle_collision_checker",
+        remappings=[
+            ("input/lanelet_map_bin", "/map/vector_map"),
+            ("input/obstacle_pointcloud", "/perception/obstacle_segmentation/pointcloud"),
+            ("input/reference_trajectory", "/planning/scenario_planning/trajectory"),
+            (
+                "input/predicted_trajectory",
+                "/control/trajectory_follower/lateral/predicted_trajectory",
+            ),
+            ("input/odometry", "/localization/kinematic_state"),
+        ],
+        parameters=[
+            obstacle_collision_checker_param,
+            vehicle_info_param,
+        ],
+        extra_arguments=[{"use_intra_process_comms": LaunchConfiguration("use_intra_process")}],
+    )
+
+    obstacle_collision_checker_loader = LoadComposableNodes(
+        condition=IfCondition(LaunchConfiguration("enable_obstacle_collision_checker")),
+        composable_node_descriptions=[obstacle_collision_checker_component],
+        target_container="/control/control_container",
+    )
+
+    glog_component = ComposableNode(
+        package="glog_component",
+        plugin="GlogComponent",
+        name="glog_component",
+    )
+
+    # set container to run all required components in the same process
+    container = ComposableNodeContainer(
+        name="control_container",
+        namespace="",
+        package="rclcpp_components",
+        executable=LaunchConfiguration("container_executable"),
+        composable_node_descriptions=[
+            controller_component,
+            control_validator_component,
+            lane_departure_component,
+            shift_decider_component,
+            vehicle_cmd_gate_component,
+            operation_mode_transition_manager_component,
+            glog_component,
+        ],
+    )
+
+    group = GroupAction(
+        [
+            PushRosNamespace("control"),
+            container,
+            external_cmd_selector_loader,
+            external_cmd_converter_loader,
+            obstacle_collision_checker_loader,
+            autonomous_emergency_braking_loader,
+            predicted_path_checker_loader,
+        ]
+    )
+
+    return [group]
+
+
+def generate_launch_description():
+    launch_arguments = []
+
+    def add_launch_arg(name: str, default_value=None, description=None):
+        launch_arguments.append(
+            DeclareLaunchArgument(name, default_value=default_value, description=description)
+        )
+
+    # option
+    add_launch_arg("vehicle_param_file")
+    add_launch_arg("vehicle_id")
+    add_launch_arg("enable_obstacle_collision_checker")
+    add_launch_arg("lateral_controller_mode")
+    add_launch_arg("longitudinal_controller_mode")
+    # common param path
+    add_launch_arg("nearest_search_param_path")
+    # package param path
+    add_launch_arg("trajectory_follower_node_param_path")
+    add_launch_arg("lat_controller_param_path")
+    add_launch_arg("lon_controller_param_path")
+    add_launch_arg("vehicle_cmd_gate_param_path")
+    add_launch_arg("lane_departure_checker_param_path")
+    add_launch_arg("control_validator_param_path")
+    add_launch_arg("operation_mode_transition_manager_param_path")
+    add_launch_arg("shift_decider_param_path")
+    add_launch_arg("obstacle_collision_checker_param_path")
+    add_launch_arg("external_cmd_selector_param_path")
+    add_launch_arg("aeb_param_path")
+    add_launch_arg("predicted_path_checker_param_path")
+    add_launch_arg("enable_predicted_path_checker")
+    add_launch_arg("enable_autonomous_emergency_braking")
+    add_launch_arg("check_external_emergency_heartbeat")
+
+    # component
+    add_launch_arg("use_intra_process", "false", "use ROS 2 component container communication")
+    add_launch_arg("use_multithread", "true", "use multithread")
+    set_container_executable = SetLaunchConfiguration(
+        "container_executable",
+        "component_container",
+        condition=UnlessCondition(LaunchConfiguration("use_multithread")),
+    )
+    set_container_mt_executable = SetLaunchConfiguration(
+        "container_executable",
+        "component_container_mt",
+        condition=IfCondition(LaunchConfiguration("use_multithread")),
+    )
+    return launch.LaunchDescription(
+        launch_arguments
+        + [
+            set_container_executable,
+            set_container_mt_executable,
+        ]
+        + [OpaqueFunction(function=launch_setup)]
+    )
diff --git a/launch/tier4_planning_launch/launch/planning.main.mrm-v0.6.tmp.launch.xml b/launch/tier4_planning_launch/launch/planning.main.mrm-v0.6.tmp.launch.xml
new file mode 100644
index 0000000000000..120c55f0cae8d
--- /dev/null
+++ b/launch/tier4_planning_launch/launch/planning.main.mrm-v0.6.tmp.launch.xml
@@ -0,0 +1,47 @@
+<launch>
+  <!-- planning module -->
+
+  <!-- mission planner -->
+  <arg name="mission_planner_param_path"/>
+  <!-- parking -->
+  <arg name="freespace_planner_param_path"/>
+  <!-- planning validator -->
+  <arg name="planning_validator_param_path"/>
+  <!-- Auto mode setting-->
+  <arg name="enable_all_modules_auto_mode"/>
+  <arg name="is_simulation"/>
+
+  <group>
+    <push-ros-namespace namespace="planning"/>
+    <!-- mission planning module -->
+    <group>
+      <push-ros-namespace namespace="mission_planning"/>
+      <include file="$(find-pkg-share tier4_planning_launch)/launch/mission_planning/mission_planning.launch.xml">
+        <arg name="mission_planner_param_path" value="$(var mission_planner_param_path)"/>
+      </include>
+    </group>
+
+    <!-- scenario planning module -->
+    <group>
+      <push-ros-namespace namespace="scenario_planning"/>
+      <include file="$(find-pkg-share tier4_planning_launch)/launch/scenario_planning/scenario_planning.launch.xml">
+        <arg name="enable_all_modules_auto_mode" value="$(var enable_all_modules_auto_mode)"/>
+        <arg name="is_simulation" value="$(var is_simulation)"/>
+      </include>
+    </group>
+
+    <!-- planning validator -->
+    <group>
+      <include file="$(find-pkg-share planning_validator)/launch/planning_validator.launch.xml">
+        <arg name="input_trajectory" value="/planning/scenario_planning/motion_velocity_smoother/trajectory"/>
+        <arg name="output_trajectory" value="/tmp/planning/scenario_planning/trajectory"/>
+        <arg name="planning_validator_param_path" value="$(var planning_validator_param_path)"/>
+      </include>
+    </group>
+
+    <!-- planning evaluator -->
+    <group>
+      <include file="$(find-pkg-share planning_evaluator)/launch/planning_evaluator.launch.xml"/>
+    </group>
+  </group>
+</launch>
diff --git a/launch/tier4_system_launch/launch/system.main.mrm-v0.6.tmp.launch.xml b/launch/tier4_system_launch/launch/system.main.mrm-v0.6.tmp.launch.xml
new file mode 100644
index 0000000000000..fbd38dccd80ec
--- /dev/null
+++ b/launch/tier4_system_launch/launch/system.main.mrm-v0.6.tmp.launch.xml
@@ -0,0 +1,192 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<launch>
+  <!-- Parameter files -->
+  <arg name="component_state_monitor_topic_path"/>
+  <arg name="emergency_handler_param_path"/>
+  <arg name="duplicated_node_checker_param_path"/>
+  <arg name="mrm_comfortable_stop_operator_param_path"/>
+  <arg name="mrm_emergency_stop_operator_param_path"/>
+  <arg name="hazard_lights_selector_param_path"/>
+  <arg name="dummy_diag_publisher_param_path"/>
+  <arg name="system_monitor_cpu_monitor_param_path"/>
+  <arg name="system_monitor_gpu_monitor_param_path"/>
+  <arg name="system_monitor_hdd_monitor_param_path"/>
+  <arg name="system_monitor_mem_monitor_param_path"/>
+  <arg name="system_monitor_net_monitor_param_path"/>
+  <arg name="system_monitor_ntp_monitor_param_path"/>
+  <arg name="system_monitor_process_monitor_param_path"/>
+  <arg name="system_monitor_voltage_monitor_param_path"/>
+
+  <arg name="launch_system_monitor" default="true" description="launch system monitor"/>
+  <arg name="launch_dummy_diag_publisher" description="launch dummy diag publisher"/>
+  <arg name="run_mode" default="online" description="options: online, logging_simulation, planning_simulation"/>
+  <arg name="sensor_model" description="sensor model name"/>
+
+  <arg name="use_diagnostic_graph" default="false" description="use diagnostic graph packages"/>
+  <arg name="mrm_handler_param_path" if="$(var use_diagnostic_graph)"/>
+  <arg name="diagnostic_graph_aggregator_param_path" if="$(var use_diagnostic_graph)"/>
+  <arg name="diagnostic_graph_aggregator_graph_path" if="$(var use_diagnostic_graph)"/>
+  <arg name="diagnostic_graph_aggregator_planning_simulator_graph_path" if="$(var use_diagnostic_graph)"/>
+
+  <let name="sensor_launch_pkg" value="$(find-pkg-share $(var sensor_model)_launch)"/>
+
+  <!-- Dummy Diag Publisher -->
+  <arg name="launch_rqt_reconfigure" default="false"/>
+  <arg name="launch_rqt_runtime_monitor" default="false"/>
+  <arg name="launch_rqt_robot_monitor" default="false"/>
+  <arg name="launch_rqt_runtime_monitor_err" default="false"/>
+
+  <group>
+    <push-ros-namespace namespace="/system"/>
+
+    <!-- System Monitor -->
+    <group if="$(var launch_system_monitor)">
+      <push-ros-namespace namespace="system_monitor"/>
+      <include file="$(find-pkg-share system_monitor)/launch/system_monitor.launch.xml">
+        <arg name="cpu_monitor_config_file" value="$(var system_monitor_cpu_monitor_param_path)"/>
+        <arg name="gpu_monitor_config_file" value="$(var system_monitor_gpu_monitor_param_path)"/>
+        <arg name="hdd_monitor_config_file" value="$(var system_monitor_hdd_monitor_param_path)"/>
+        <arg name="mem_monitor_config_file" value="$(var system_monitor_mem_monitor_param_path)"/>
+        <arg name="net_monitor_config_file" value="$(var system_monitor_net_monitor_param_path)"/>
+        <arg name="ntp_monitor_config_file" value="$(var system_monitor_ntp_monitor_param_path)"/>
+        <arg name="process_monitor_config_file" value="$(var system_monitor_process_monitor_param_path)"/>
+        <arg name="voltage_monitor_config_file" value="$(var system_monitor_voltage_monitor_param_path)"/>
+      </include>
+    </group>
+
+    <!-- Service Log Checker -->
+    <group>
+      <include file="$(find-pkg-share component_interface_tools)/launch/service_log_checker.launch.xml"/>
+    </group>
+
+    <!-- Component State Monitor -->
+    <group>
+      <include file="$(find-pkg-share component_state_monitor)/launch/component_state_monitor.launch.py">
+        <arg name="mode" value="$(var run_mode)"/>
+        <arg name="file" value="$(var component_state_monitor_topic_path)"/>
+      </include>
+    </group>
+
+    <!-- Error Monitor -->
+    <group unless="$(var use_diagnostic_graph)">
+      <let name="config_file" value="$(var system_error_monitor_param_path)" if="$(eval &quot;'$(var run_mode)'=='online'&quot;)"/>
+      <let name="config_file" value="$(var system_error_monitor_param_path)" if="$(eval &quot;'$(var run_mode)'=='logging_simulation'&quot;)"/>
+      <let name="config_file" value="$(var system_error_monitor_planning_simulator_param_path)" if="$(eval &quot;'$(var run_mode)'=='planning_simulation'&quot;)"/>
+      <include file="$(find-pkg-share system_error_monitor)/launch/system_error_monitor.launch.xml">
+        <arg name="config_file" value="$(var config_file)"/>
+        <arg name="extra_agg_config_file_sensing" value="$(var sensor_launch_pkg)/config/diagnostic_aggregator/sensor_kit.param.yaml"/>
+        <arg name="extra_agg_config_file_system" value="$(var diagnostic_aggregator_system_param_path)"/>
+        <arg name="extra_agg_config_file_vehicle" value="$(var diagnostic_aggregator_vehicle_param_path)"/>
+        <arg name="use_emergency_hold" value="false"/>
+      </include>
+    </group>
+
+    <!-- Emergency Handler -->
+    <group unless="$(var use_diagnostic_graph)">
+      <include file="$(find-pkg-share emergency_handler)/launch/emergency_handler.launch.xml">
+        <arg name="config_file" value="$(var emergency_handler_param_path)"/>
+      </include>
+    </group>
+
+    <group>
+      <include file="$(find-pkg-share duplicated_node_checker)/launch/duplicated_node_checker.launch.xml">
+        <arg name="config_file" value="$(var duplicated_node_checker_param_path)"/>
+      </include>
+    </group>
+
+    <!-- MRM Operator -->
+    <group>
+      <include file="$(find-pkg-share mrm_comfortable_stop_operator)/launch/mrm_comfortable_stop_operator.launch.py">
+        <arg name="config_file" value="$(var mrm_comfortable_stop_operator_param_path)"/>
+      </include>
+    </group>
+    <group>
+      <include file="$(find-pkg-share mrm_emergency_stop_operator)/launch/mrm_emergency_stop_operator.launch.py">
+        <arg name="config_file" value="$(var mrm_emergency_stop_operator_param_path)"/>
+      </include>
+    </group>
+    <!-- <group>
+      <include file="$(find-pkg-share mrm_pull_over_manager)/launch/mrm_pull_over_manager.launch.xml"/>
+    </group>
+    <group>
+      <include file="$(find-pkg-share emergency_goal_manager)/launch/emergency_goal_manager.launch.xml"/>
+    </group> -->
+
+    <!-- MRM Handler -->
+    <group if="$(var use_diagnostic_graph)">
+      <include file="$(find-pkg-share mrm_handler)/launch/mrm_handler.launch.xml">
+        <arg name="config_file" value="$(var mrm_handler_param_path)"/>
+      </include>
+    </group>
+
+    <!-- Diagnostic Graph Aggregator -->
+    <group if="$(var use_diagnostic_graph)">
+      <let name="graph_file" value="$(var diagnostic_graph_aggregator_graph_path)" if="$(eval &quot;'$(var run_mode)'=='online'&quot;)"/>
+      <let name="graph_file" value="$(var diagnostic_graph_aggregator_graph_path)" if="$(eval &quot;'$(var run_mode)'=='logging_simulation'&quot;)"/>
+      <let name="graph_file" value="$(var diagnostic_graph_aggregator_planning_simulator_graph_path)" if="$(eval &quot;'$(var run_mode)'=='planning_simulation'&quot;)"/>
+      <include file="$(find-pkg-share diagnostic_graph_aggregator)/launch/aggregator.launch.xml">
+        <arg name="param_file" value="$(var diagnostic_graph_aggregator_param_path)"/>
+        <arg name="graph_file" value="$(var graph_file)"/>
+      </include>
+    </group>
+
+    <!-- Hazard Status Converter -->
+    <group if="$(var use_diagnostic_graph)">
+      <include file="$(find-pkg-share hazard_status_converter)/launch/hazard_status_converter.launch.xml"/>
+    </group>
+  </group>
+
+  <!-- hazard selector -->
+  <group>
+    <include file="$(find-pkg-share hazard_lights_selector)/launch/hazard_lights_selector.launch.xml">
+      <arg name="param_path" value="$(var hazard_lights_selector_param_path)"/>
+    </include>
+  </group>
+
+  <!-- Dummy Diag Publisher -->
+  <group if="$(var launch_dummy_diag_publisher)">
+    <include file="$(find-pkg-share dummy_diag_publisher)/launch/dummy_diag_publisher.launch.xml">
+      <arg name="config_file" value="$(var dummy_diag_publisher_param_path)"/>
+      <arg name="extra_config_file_sensor" value="$(var sensor_launch_pkg)/config/dummy_diag_publisher/sensor_kit.param.yaml"/>
+      <arg name="launch_rqt_reconfigure" value="$(var launch_rqt_reconfigure)"/>
+      <arg name="launch_rqt_runtime_monitor" value="$(var launch_rqt_runtime_monitor)"/>
+      <arg name="launch_rqt_robot_monitor" value="$(var launch_rqt_robot_monitor)"/>
+      <arg name="launch_rqt_runtime_monitor_err" value="$(var launch_rqt_runtime_monitor_err)"/>
+    </include>
+  </group>
+
+  <!-- Control Cmd Switcher for MRMv0.6 one host test-->
+  <group>
+    <include file="$(find-pkg-share control_cmd_switcher)/launch/control_cmd_switcher.launch.xml"/>
+  </group>
+
+    <!-- Leader Election Converter-->
+  <group>
+    <include file="$(find-pkg-share leader_election_converter)/launch/leader_election_converter.launch.xml"/>
+  </group>
+
+  <!-- topic state montor for MRMv0.6 one host test-->
+  <group>
+    <include file="$(find-pkg-share topic_state_monitor)/launch/topic_state_monitor.launch.xml">
+      <arg name="node_name_suffix" value="scenario_planning_trajectry"/>
+      <arg name="topic" value="/planning/scenario_planning/trajectory"/>
+      <arg name="topic_type" value="autoware_auto_planning_msgs/msg/Trajectory"/>
+      <arg name="diag_name" value="publish_to_sub_status"/>
+      <arg name="warn_rate" value="5.0"/>
+      <arg name="error_rate" value="1.0"/>
+      <arg name="timeout" value="1.0"/>
+    </include>
+
+    <!-- <include file="$(find-pkg-share topic_state_monitor)/launch/topic_state_monitor.launch.xml">
+      <arg name="node_name_suffix" value="pose_estimator_pose_with_covariance"/>
+      <arg name="topic" value="	/localization/pose_estimator/pose_with_covariance"/>
+      <arg name="topic_type" value="geometry_msgs/msg/PoseWithCovarianceStamped"/>
+      <arg name="diag_name" value="publish_to_sub_status"/>
+      <arg name="warn_rate" value=""/>
+      <arg name="error_rate" value=""/>
+      <arg name="timeout" value=""/>
+    </include> -->
+  </group>
+
+
+</launch>
diff --git a/launch/tier4_system_launch/package.xml b/launch/tier4_system_launch/package.xml
index 789cf136f1152..42c57a7b4a22b 100644
--- a/launch/tier4_system_launch/package.xml
+++ b/launch/tier4_system_launch/package.xml
@@ -15,6 +15,8 @@
   <exec_depend>emergency_handler</exec_depend>
   <exec_depend>system_error_monitor</exec_depend>
   <exec_depend>system_monitor</exec_depend>
+  <exec_depend>control_cmd_switcher</exec_depend>
+  <exec_depend>leader_election_converter</exec_depend>
 
   <test_depend>ament_lint_auto</test_depend>
   <test_depend>autoware_lint_common</test_depend>
diff --git a/system/mrm_handler/include/mrm_handler/mrm_handler_core.hpp b/system/mrm_handler/include/mrm_handler/mrm_handler_core.hpp
index 286151b90fdf5..a7aa44d702371 100644
--- a/system/mrm_handler/include/mrm_handler/mrm_handler_core.hpp
+++ b/system/mrm_handler/include/mrm_handler/mrm_handler_core.hpp
@@ -25,7 +25,8 @@
 // Autoware
 #include <tier4_autoware_utils/ros/update_param.hpp>
 
-#include <autoware_adapi_v1_msgs/msg/mrm_state.hpp>
+#include <tier4_system_msgs/msg/mrm_state.hpp>
+#include <tier4_system_msgs/msg/mrm_behavior.hpp>
 #include <autoware_adapi_v1_msgs/msg/operation_mode_state.hpp>
 #include <autoware_auto_vehicle_msgs/msg/control_mode_report.hpp>
 #include <autoware_auto_vehicle_msgs/msg/gear_command.hpp>
@@ -117,9 +118,9 @@ class MrmHandler : public rclcpp::Node
   void publishHazardCmd();
   void publishGearCmd();
 
-  rclcpp::Publisher<autoware_adapi_v1_msgs::msg::MrmState>::SharedPtr pub_mrm_state_;
+  rclcpp::Publisher<tier4_system_msgs::msg::MrmState>::SharedPtr pub_mrm_state_;
 
-  autoware_adapi_v1_msgs::msg::MrmState mrm_state_;
+  tier4_system_msgs::msg::MrmState mrm_state_;
   void publishMrmState();
 
   // parameter callback
@@ -136,7 +137,7 @@ class MrmHandler : public rclcpp::Node
   rclcpp::Client<tier4_system_msgs::srv::OperateMrm>::SharedPtr client_mrm_emergency_stop_;
 
   bool requestMrmBehavior(
-    const autoware_adapi_v1_msgs::msg::MrmState::_behavior_type & mrm_behavior,
+    const tier4_system_msgs::msg::MrmBehavior::_type_type & mrm_behavior,
     RequestType request_type) const;
   void logMrmCallingResult(
     const tier4_system_msgs::srv::OperateMrm::Response & result, const std::string & behavior,
@@ -164,7 +165,7 @@ class MrmHandler : public rclcpp::Node
   void updateMrmState();
   void operateMrm();
   void handleFailedRequest();
-  autoware_adapi_v1_msgs::msg::MrmState::_behavior_type getCurrentMrmBehavior();
+  tier4_system_msgs::msg::MrmBehavior::_type_type getCurrentMrmBehavior();
   bool isStopped();
   bool isEmergency() const;
   bool isArrivedAtGoal();
diff --git a/system/mrm_handler/src/mrm_handler/mrm_handler_core.cpp b/system/mrm_handler/src/mrm_handler/mrm_handler_core.cpp
index 9d31c68f161b5..7c05ef1f18998 100644
--- a/system/mrm_handler/src/mrm_handler/mrm_handler_core.cpp
+++ b/system/mrm_handler/src/mrm_handler/mrm_handler_core.cpp
@@ -68,7 +68,7 @@ MrmHandler::MrmHandler() : Node("mrm_handler")
   pub_gear_cmd_ =
     create_publisher<autoware_auto_vehicle_msgs::msg::GearCommand>("~/output/gear", rclcpp::QoS{1});
   pub_mrm_state_ =
-    create_publisher<autoware_adapi_v1_msgs::msg::MrmState>("~/output/mrm/state", rclcpp::QoS{1});
+    create_publisher<tier4_system_msgs::msg::MrmState>("~/output/mrm/state", rclcpp::QoS{1});
 
   // Clients
   client_mrm_pull_over_group_ = create_callback_group(rclcpp::CallbackGroupType::MutuallyExclusive);
@@ -95,11 +95,11 @@ MrmHandler::MrmHandler() : Node("mrm_handler")
   mrm_emergency_stop_status_ = std::make_shared<const tier4_system_msgs::msg::MrmBehaviorStatus>();
   operation_mode_state_ = std::make_shared<const autoware_adapi_v1_msgs::msg::OperationModeState>();
   mrm_state_.stamp = this->now();
-  mrm_state_.state = autoware_adapi_v1_msgs::msg::MrmState::NORMAL;
-  mrm_state_.behavior = autoware_adapi_v1_msgs::msg::MrmState::NONE;
+  mrm_state_.state = tier4_system_msgs::msg::MrmState::NORMAL;
+  mrm_state_.behavior.type = tier4_system_msgs::msg::MrmBehavior::NONE;
   is_operation_mode_availability_timeout = false;
 
-  // Timer
+  // Timera
   const auto update_period_ns = rclcpp::Rate(param_.update_rate).period();
   timer_ = rclcpp::create_timer(
     this, get_clock(), update_period_ns, std::bind(&MrmHandler::onTimer, this));
@@ -227,16 +227,17 @@ void MrmHandler::publishMrmState()
 
 void MrmHandler::operateMrm()
 {
-  using autoware_adapi_v1_msgs::msg::MrmState;
+  using tier4_system_msgs::msg::MrmState;
+  using tier4_system_msgs::msg::MrmBehavior;
 
   if (mrm_state_.state == MrmState::NORMAL) {
     // Cancel MRM behavior when returning to NORMAL state
-    const auto current_mrm_behavior = MrmState::NONE;
-    if (current_mrm_behavior == mrm_state_.behavior) {
+    const auto current_mrm_behavior = MrmBehavior::NONE;
+    if (current_mrm_behavior == mrm_state_.behavior.type) {
       return;
     }
-    if (requestMrmBehavior(mrm_state_.behavior, RequestType::CANCEL)) {
-      mrm_state_.behavior = current_mrm_behavior;
+    if (requestMrmBehavior(mrm_state_.behavior.type, RequestType::CANCEL)) {
+      mrm_state_.behavior.type = current_mrm_behavior;
     } else {
       handleFailedRequest();
     }
@@ -244,13 +245,13 @@ void MrmHandler::operateMrm()
   }
   if (mrm_state_.state == MrmState::MRM_OPERATING) {
     const auto current_mrm_behavior = getCurrentMrmBehavior();
-    if (current_mrm_behavior == mrm_state_.behavior) {
+    if (current_mrm_behavior == mrm_state_.behavior.type) {
       return;
     }
-    if (!requestMrmBehavior(mrm_state_.behavior, RequestType::CANCEL)) {
+    if (!requestMrmBehavior(mrm_state_.behavior.type, RequestType::CANCEL)) {
       handleFailedRequest();
     } else if (requestMrmBehavior(current_mrm_behavior, RequestType::CALL)) {
-      mrm_state_.behavior = current_mrm_behavior;
+      mrm_state_.behavior.type = current_mrm_behavior;
     } else {
       handleFailedRequest();
     }
@@ -270,21 +271,23 @@ void MrmHandler::operateMrm()
 
 void MrmHandler::handleFailedRequest()
 {
-  using autoware_adapi_v1_msgs::msg::MrmState;
+  using tier4_system_msgs::msg::MrmState;
+  using tier4_system_msgs::msg::MrmBehavior;
 
-  if (requestMrmBehavior(MrmState::EMERGENCY_STOP, CALL)) {
+  if (requestMrmBehavior(MrmBehavior::EMERGENCY_STOP, CALL)) {
     if (mrm_state_.state != MrmState::MRM_OPERATING) transitionTo(MrmState::MRM_OPERATING);
   } else {
     transitionTo(MrmState::MRM_FAILED);
   }
-  mrm_state_.behavior = MrmState::EMERGENCY_STOP;
+  mrm_state_.behavior.type = MrmBehavior::EMERGENCY_STOP;
 }
 
 bool MrmHandler::requestMrmBehavior(
-  const autoware_adapi_v1_msgs::msg::MrmState::_behavior_type & mrm_behavior,
+  const tier4_system_msgs::msg::MrmBehavior::_type_type & mrm_behavior,
   RequestType request_type) const
 {
-  using autoware_adapi_v1_msgs::msg::MrmState;
+  using tier4_system_msgs::msg::MrmState;
+  using tier4_system_msgs::msg::MrmBehavior;
 
   auto request = std::make_shared<tier4_system_msgs::srv::OperateMrm::Request>();
   if (request_type == RequestType::CALL) {
@@ -300,16 +303,16 @@ bool MrmHandler::requestMrmBehavior(
   std::shared_future<std::shared_ptr<tier4_system_msgs::srv::OperateMrm::Response>> future;
 
   const auto behavior2string = [](const int behavior) {
-    if (behavior == MrmState::NONE) {
+    if (behavior == MrmBehavior::NONE) {
       return "NONE";
     }
-    if (behavior == MrmState::PULL_OVER) {
+    if (behavior == MrmBehavior::PULL_OVER) {
       return "PULL_OVER";
     }
-    if (behavior == MrmState::COMFORTABLE_STOP) {
+    if (behavior == MrmBehavior::COMFORTABLE_STOP) {
       return "COMFORTABLE_STOP";
     }
-    if (behavior == MrmState::EMERGENCY_STOP) {
+    if (behavior == MrmBehavior::EMERGENCY_STOP) {
       return "EMERGENCY_STOP";
     }
     const auto msg = "invalid behavior: " + std::to_string(behavior);
@@ -317,18 +320,18 @@ bool MrmHandler::requestMrmBehavior(
   };
 
   switch (mrm_behavior) {
-    case MrmState::NONE:
+    case MrmBehavior::NONE:
       RCLCPP_WARN(this->get_logger(), "MRM behavior is None. Do nothing.");
       return true;
-    case MrmState::PULL_OVER: {
+    case MrmBehavior::PULL_OVER: {
       future = client_mrm_pull_over_->async_send_request(request).future.share();
       break;
     }
-    case MrmState::COMFORTABLE_STOP: {
+    case MrmBehavior::COMFORTABLE_STOP: {
       future = client_mrm_comfortable_stop_->async_send_request(request).future.share();
       break;
     }
-    case MrmState::EMERGENCY_STOP: {
+    case MrmBehavior::EMERGENCY_STOP: {
       future = client_mrm_emergency_stop_->async_send_request(request).future.share();
       break;
     }
@@ -433,7 +436,7 @@ void MrmHandler::onTimer()
 
 void MrmHandler::transitionTo(const int new_state)
 {
-  using autoware_adapi_v1_msgs::msg::MrmState;
+  using tier4_system_msgs::msg::MrmState;
 
   const auto state2string = [](const int state) {
     if (state == MrmState::NORMAL) {
@@ -462,7 +465,8 @@ void MrmHandler::transitionTo(const int new_state)
 
 void MrmHandler::updateMrmState()
 {
-  using autoware_adapi_v1_msgs::msg::MrmState;
+  using tier4_system_msgs::msg::MrmState;
+  using tier4_system_msgs::msg::MrmBehavior;
   using autoware_auto_vehicle_msgs::msg::ControlModeReport;
 
   // Check emergency
@@ -491,7 +495,7 @@ void MrmHandler::updateMrmState()
 
     if (mrm_state_.state == MrmState::MRM_OPERATING) {
       // TODO(TetsuKawa): Check MRC is accomplished
-      if (mrm_state_.behavior == MrmState::PULL_OVER) {
+      if (mrm_state_.behavior.type == MrmBehavior::PULL_OVER) {
         if (isStopped() && isArrivedAtGoal()) {
           transitionTo(MrmState::MRM_SUCCEEDED);
           return;
@@ -504,7 +508,7 @@ void MrmHandler::updateMrmState()
       }
     } else if (mrm_state_.state == MrmState::MRM_SUCCEEDED) {
       const auto current_mrm_behavior = getCurrentMrmBehavior();
-      if (current_mrm_behavior != mrm_state_.behavior) {
+      if (current_mrm_behavior != mrm_state_.behavior.type) {
         transitionTo(MrmState::MRM_OPERATING);
       }
     } else if (mrm_state_.state == MrmState::MRM_FAILED) {
@@ -516,85 +520,86 @@ void MrmHandler::updateMrmState()
   }
 }
 
-autoware_adapi_v1_msgs::msg::MrmState::_behavior_type MrmHandler::getCurrentMrmBehavior()
+tier4_system_msgs::msg::MrmBehavior::_type_type MrmHandler::getCurrentMrmBehavior()
 {
-  using autoware_adapi_v1_msgs::msg::MrmState;
+  using tier4_system_msgs::msg::MrmState;
+  using tier4_system_msgs::msg::MrmBehavior;
   using tier4_system_msgs::msg::OperationModeAvailability;
 
   // State machine
-  if (mrm_state_.behavior == MrmState::NONE) {
+  if (mrm_state_.behavior.type == MrmBehavior::NONE) {
     if (is_operation_mode_availability_timeout) {
-      return MrmState::EMERGENCY_STOP;
+      return MrmBehavior::EMERGENCY_STOP;
     }
     if (operation_mode_availability_->pull_over) {
       if (param_.use_pull_over) {
-        return MrmState::PULL_OVER;
+        return MrmBehavior::PULL_OVER;
       }
     }
     if (operation_mode_availability_->comfortable_stop) {
       if (param_.use_comfortable_stop) {
-        return MrmState::COMFORTABLE_STOP;
+        return MrmBehavior::COMFORTABLE_STOP;
       }
     }
     if (!operation_mode_availability_->emergency_stop) {
       RCLCPP_WARN(this->get_logger(), "no mrm operation available: operate emergency_stop");
     }
-    return MrmState::EMERGENCY_STOP;
+    return MrmBehavior::EMERGENCY_STOP;
   }
-  if (mrm_state_.behavior == MrmState::PULL_OVER) {
+  if (mrm_state_.behavior.type == MrmBehavior::PULL_OVER) {
     if (is_operation_mode_availability_timeout) {
-      return MrmState::EMERGENCY_STOP;
+      return MrmBehavior::EMERGENCY_STOP;
     }
     if (operation_mode_availability_->pull_over) {
       if (param_.use_pull_over) {
-        return MrmState::PULL_OVER;
+        return MrmBehavior::PULL_OVER;
       }
     }
     if (operation_mode_availability_->comfortable_stop) {
       if (param_.use_comfortable_stop) {
-        return MrmState::COMFORTABLE_STOP;
+        return MrmBehavior::COMFORTABLE_STOP;
       }
     }
     if (!operation_mode_availability_->emergency_stop) {
       RCLCPP_WARN(this->get_logger(), "no mrm operation available: operate emergency_stop");
     }
-    return MrmState::EMERGENCY_STOP;
+    return MrmBehavior::EMERGENCY_STOP;
   }
-  if (mrm_state_.behavior == MrmState::COMFORTABLE_STOP) {
+  if (mrm_state_.behavior.type == MrmBehavior::COMFORTABLE_STOP) {
     if (is_operation_mode_availability_timeout) {
-      return MrmState::EMERGENCY_STOP;
+      return MrmBehavior::EMERGENCY_STOP;
     }
     if (isStopped() && operation_mode_availability_->pull_over) {
       if (param_.use_pull_over && param_.use_pull_over_after_stopped) {
-        return MrmState::PULL_OVER;
+        return MrmBehavior::PULL_OVER;
       }
     }
     if (operation_mode_availability_->comfortable_stop) {
       if (param_.use_comfortable_stop) {
-        return MrmState::COMFORTABLE_STOP;
+        return MrmBehavior::COMFORTABLE_STOP;
       }
     }
     if (!operation_mode_availability_->emergency_stop) {
       RCLCPP_WARN(this->get_logger(), "no mrm operation available: operate emergency_stop");
     }
-    return MrmState::EMERGENCY_STOP;
+    return MrmBehavior::EMERGENCY_STOP;
   }
-  if (mrm_state_.behavior == MrmState::EMERGENCY_STOP) {
+  if (mrm_state_.behavior.type == MrmBehavior::EMERGENCY_STOP) {
     if (is_operation_mode_availability_timeout) {
-      return MrmState::EMERGENCY_STOP;
+      return MrmBehavior::EMERGENCY_STOP;
     }
     if (isStopped() && operation_mode_availability_->pull_over) {
       if (param_.use_pull_over && param_.use_pull_over_after_stopped) {
-        return MrmState::PULL_OVER;
+        return MrmBehavior::PULL_OVER;
       }
     }
     if (!operation_mode_availability_->emergency_stop) {
       RCLCPP_WARN(this->get_logger(), "no mrm operation available: operate emergency_stop");
     }
-    return MrmState::EMERGENCY_STOP;
+    return MrmBehavior::EMERGENCY_STOP;
   }
 
-  return mrm_state_.behavior;
+  return mrm_state_.behavior.type;
 }
 
 bool MrmHandler::isStopped()