diff --git a/package.xml b/package.xml
index b89ba8f..ed20810 100644
--- a/package.xml
+++ b/package.xml
@@ -29,7 +29,8 @@
   <exec_depend>rclpy</exec_depend>
   <exec_depend>tf2_ros</exec_depend>
   <exec_depend>rmcs_local_map</exec_depend>
-
+  <exec_depend>rmcs-relocation</exec_depend> 
+   
   <export>
     <build_type>ament_cmake</build_type>
   </export>
diff --git a/src/cxx/component.cc b/src/cxx/component.cc
index 6c543c8..94210a6 100644
--- a/src/cxx/component.cc
+++ b/src/cxx/component.cc
@@ -5,10 +5,16 @@
 #endif
 
 #include "cxx/context.hh"
+#include "cxx/util/localization/engine.hh"
 #include "cxx/util/navigation/navigation.hh"
 #include "cxx/util/node_mixin.hh"
-
+#include <atomic>
 #include <filesystem>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
 
 #include <Eigen/Geometry>
 #include <ament_index_cpp/get_package_share_directory.hpp>
@@ -43,6 +49,8 @@ class Navigation
 
     details::Context context;
     details::Navigation navigation;
+    std::unique_ptr<Localization> localization;
+    bool relocalization_enabled = true;
 
     struct Command {
         OutputInterface<Eigen::Vector2d> chassis_speed;
@@ -102,6 +110,34 @@ class Navigation
         api.set_function("update_chassis_vel", [this](double x, double y) {
             *command.chassis_speed = Eigen::Vector2d{x, y};
         });
+        // 三个 mode 共享同一个 disabled-guard + 委托模板。lua 端别名（initial / local_ / wide）
+        const auto bind_relocalize = [this, &api](std::string_view name, RelocalizeMode mode) {
+            api.set_function(
+                std::string{name}, [this, name, mode](double x, double y, double yaw) {
+                    if (!relocalization_enabled || !localization) {
+                        warn("{} ignored: disabled", name);
+                        return false;
+                    }
+                    return localization->relocalize(mode, x, y, yaw);
+                });
+        };
+        bind_relocalize("relocalize_initial", RelocalizeMode::Initial);
+        bind_relocalize("relocalize_local",   RelocalizeMode::Local);
+        bind_relocalize("relocalize_wide",    RelocalizeMode::Wide);
+
+        // status 转 lua table：disabled/enabled。
+        api.set_function("relocalize_status", [this]() {
+            const auto status = (relocalization_enabled && localization)
+                                  ? localization->relocalize_status()
+                                  : RelocalizeStatus{.message = "disabled"};
+            return lua->create_table_with(
+                "state", static_cast<int>(status.state), "success", status.success,
+                "message", status.message, "fitness_score", status.fitness_score, "confidence",
+                status.confidence, "estimated_x", status.estimated_x, "estimated_y",
+                status.estimated_y, "estimated_z", status.estimated_z, "estimated_qx",
+                status.estimated_qx, "estimated_qy", status.estimated_qy, "estimated_qz",
+                status.estimated_qz, "estimated_qw", status.estimated_qw);
+        });
     }
 
     auto make_option_injection() {
@@ -232,6 +268,21 @@ class Navigation
         , navigation{*this} {
 
         mock_context = param<bool>("mock_context");
+        relocalization_enabled =
+            has_parameter("enable_relocalization")
+                ? get_parameter_or<bool>("enable_relocalization", true)
+                : true;
+        if (relocalization_enabled) {
+            auto config = Localization::Config{ .rclcpp = *this };
+            if (has_parameter("localization.service_name"))
+                config.service_name = get_parameter("localization.service_name").as_string();
+            if (has_parameter("localization.request_timeout_sec"))
+                config.request_timeout_sec =
+                    get_parameter("localization.request_timeout_sec").as_double();
+            localization = std::make_unique<Localization>(std::move(config));
+        } else {
+            warn("relocalization is disabled by parameter enable_relocalization=false");
+        }
 
         context.init(io_mutex, mock_context);
         command.init(*this);
diff --git a/src/cxx/util/localization/engine.cc b/src/cxx/util/localization/engine.cc
index b7bc6fe..b2627a8 100644
--- a/src/cxx/util/localization/engine.cc
+++ b/src/cxx/util/localization/engine.cc
@@ -1,74 +1,207 @@
 #include "cxx/util/localization/engine.hh"
 #include "cxx/util/node_mixin.hh"
 
-#include <pcl/io/pcd_io.h>
-#include <pcl/point_cloud.h>
-#include <pcl/point_types.h>
-#include <pcl/registration/ndt.h>
-
-#include <pcl_conversions/pcl_conversions.h>
-#include <rclcpp/subscription.hpp>
-#include <sensor_msgs/msg/point_cloud2.hpp>
+#include <algorithm>
+#include <chrono>
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <utility>
+
+#include <geometry_msgs/msg/pose.hpp>
+#include <rclcpp/client.hpp>
+#include <rclcpp/logging.hpp>
+#include <rclcpp/timer.hpp>
+#include <rmcs_msgs/srv/relocalize.hpp>
+#include <tf2/LinearMath/Quaternion.hpp>
 
 namespace rmcs::navigation {
 
-struct Localization::Impl {
-    Config config;
-    LoggerWrap<rclcpp::Node> logging;
-
-    struct Context {
-        using Point = pcl::PointXYZ;
-        using Cloud = pcl::PointCloud<Point>;
-
-        std::shared_ptr<rclcpp::Subscription<sensor_msgs::msg::PointCloud2>> subscription;
-        std::atomic<bool> stop_collecting = false;
-
-        std::shared_ptr<Cloud> map;
-        std::shared_ptr<Cloud> collected = std::make_shared<Cloud>();
-
-        explicit Context(Config& config) {
-            const auto& filename = config.map_filename;
-            if (pcl::io::loadPCDFile<Point>(filename, *map) != 0)
-                throw std::runtime_error{"Couldn't read " + filename};
-
-            auto& rclcpp = config.rclcpp;
-            subscription = rclcpp.create_subscription<sensor_msgs::msg::PointCloud2>(
-                config.topic_registered, 10,
-                [this](const std::unique_ptr<sensor_msgs::msg::PointCloud2>& msg) {
-                    if (!stop_collecting) {
-                        auto received = Cloud{};
-                        pcl::fromROSMsg(*msg, received);
-
-                        *collected += received;
-                    }
-                });
-        }
-    } context;
+namespace {
+
+using Relocalize       = rmcs_msgs::srv::Relocalize;
+using RelocalizeClient = rclcpp::Client<Relocalize>;
+
+auto yaw_to_pose(double x, double y, double yaw) -> geometry_msgs::msg::Pose {
+    auto q = tf2::Quaternion{};
+    q.setRPY(0.0, 0.0, yaw);
+    q.normalize();
+    auto pose = geometry_msgs::msg::Pose{};
+    pose.position.x    = x;
+    pose.position.y    = y;
+    pose.position.z    = 0.0;
+    pose.orientation.x = q.x();
+    pose.orientation.y = q.y();
+    pose.orientation.z = q.z();
+    pose.orientation.w = q.w();
+    return pose;
+}
+
+auto failed_status(std::string message) -> RelocalizeStatus {
+    return RelocalizeStatus{
+        .state   = RelocalizeState::FAILED,
+        .success = false,
+        .message = std::move(message),
+    };
+}
+
+auto status_from_response(const Relocalize::Response& response, bool success) -> RelocalizeStatus {
+    const auto& pose = response.estimated_world_base;
+    return RelocalizeStatus{
+        .state = success ? RelocalizeState::SUCCEEDED : RelocalizeState::FAILED, .success = success,
+        .message = response.message, .fitness_score = response.fitness_score, .confidence = response.confidence,
+        .estimated_x = pose.position.x, .estimated_y = pose.position.y, .estimated_z = pose.position.z,
+        .estimated_qx = pose.orientation.x, .estimated_qy = pose.orientation.y, .estimated_qz = pose.orientation.z,
+        .estimated_qw = pose.orientation.w,
+    };
+}
 
-    pcl::NormalDistributionsTransform<Context::Point, Context::Point> engine;
+constexpr auto mode_to_msg(RelocalizeMode mode) -> std::uint8_t {
+    switch (mode) {
+    case RelocalizeMode::Initial: return Relocalize::Request::MODE_INITIAL;
+    case RelocalizeMode::Local:   return Relocalize::Request::MODE_LOCAL;
+    case RelocalizeMode::Wide:    return Relocalize::Request::MODE_WIDE;
+    }
+    return Relocalize::Request::MODE_INITIAL;
+}
 
-    explicit Impl(Localization::Config config)
-        : config{std::move(config)}
-        , logging{config.rclcpp}
-        , context{config} {
+} // namespace
+
+/// 一次重定位请求的全生命周期。lambda 通过 shared_ptr 持有。
+struct Session {
+    mutable std::mutex mutex;
+    std::shared_ptr<RelocalizeClient> client;
+    rclcpp::Logger logger;
+    std::string service_name;
+
+    std::optional<std::int64_t> pending_id;
+    RelocalizeStatus last_status{};
+    rclcpp::TimerBase::SharedPtr timeout_timer;
+
+    Session(std::shared_ptr<RelocalizeClient> c, rclcpp::Logger lg, std::string name)
+        : client{std::move(c)}, logger{std::move(lg)}, service_name{std::move(name)} {}
+
+    /// 抢占一个 in-flight 槽位。若已在飞行中返回 false。
+    auto begin() -> bool {
+        auto lock = std::scoped_lock{mutex};
+        if (last_status.state == RelocalizeState::IN_FLIGHT)
+            return false;
+        pending_id.reset();
+        last_status =
+            RelocalizeStatus{.state = RelocalizeState::IN_FLIGHT, .message = "in_flight"};
+        return true;
+    }
 
-        engine.setTransformationEpsilon(config.ndt_result_epsilon); // 收敛判定阈值
-        engine.setStepSize(config.ndt_step_size);                   // More-Thuente 线搜索最大步长
-        engine.setResolution(config.ndt_resolution);                // NDT 网格分辨率
-        engine.setMaximumIterations(config.ndt_max_iterations);     // 最大迭代次数
+    auto track(std::int64_t id) -> void {
+        auto lock = std::scoped_lock{mutex};
+        pending_id = id;
     }
 
-    auto start_collecting(std::chrono::seconds seconds) -> std::expected<void, std::string> {
-        std::ignore = this;
-        std::ignore = seconds;
-        return {};
+    /// 写入终态。expected_id != nullopt 时仅当与当前 pending 一致才接受（过滤迟到响应）。
+    auto end(RelocalizeStatus status, std::optional<std::int64_t> expected_id = std::nullopt)
+        -> bool {
+        auto lock = std::scoped_lock{mutex};
+        if (expected_id && pending_id != *expected_id)
+            return false;
+        clear_locked();
+        last_status = std::move(status);
+        return true;
     }
 
-    auto start_localizing(const Eigen::Isometry3d& initial_solution)
-        -> std::future<std::expected<Eigen::Isometry3d, std::string>> {
-        std::ignore = this;
-        std::ignore = initial_solution;
-        return {};
+    auto snapshot() const -> RelocalizeStatus {
+        auto lock = std::scoped_lock{mutex};
+        return last_status;
+    }
+
+    /// 必须在持锁状态下调用：取消定时器、从 client 移除 pending 条目。
+    auto clear_locked() -> void {
+        if (timeout_timer) {
+            timeout_timer->cancel();
+            timeout_timer.reset();
+        }
+        if (pending_id) {
+            client->remove_pending_request(*pending_id);
+            pending_id.reset();
+        }
+    }
+};
+
+struct Localization::Impl : NodeMixin {
+    Config config;
+    rclcpp::Node& node;
+    std::shared_ptr<Session> session;
+
+    explicit Impl(Localization::Config cfg)
+        : config{std::move(cfg)}
+        , node{config.rclcpp}
+        , session{std::make_shared<Session>(
+              node.create_client<Relocalize>(config.service_name), node.get_logger(),
+              config.service_name)} {}
+
+    ~Impl() {
+        auto lock = std::scoped_lock{session->mutex};
+        session->clear_locked();
+    }
+
+    auto get_logger() const { return node.get_logger(); }
+
+    auto arm_timeout(const std::shared_ptr<Session>& s) -> void {
+        const auto timeout = std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::duration<double>{std::max(0.1, config.request_timeout_sec)});
+        auto timer = node.create_wall_timer(timeout, [s]() {
+            if (s->end(failed_status("request timeout: " + s->service_name)))
+                RCLCPP_WARN(s->logger, "relocalize request timeout: %s", s->service_name.c_str());
+        });
+        auto lock = std::scoped_lock{s->mutex};
+        if (s->timeout_timer)
+            s->timeout_timer->cancel();
+        s->timeout_timer = std::move(timer);
+    }
+
+    auto send(RelocalizeMode mode, double x, double y, double yaw) -> bool {
+        if (!session->begin()) {
+            warn("relocalize skipped: previous request is still in flight");
+            return false;
+        }
+
+        if (!session->client->service_is_ready()
+            && !session->client->wait_for_service(std::chrono::seconds(0))) {
+            warn("relocalize service unavailable: {}", config.service_name);
+            session->end(failed_status("service unavailable: " + config.service_name));
+            return false;
+        }
+
+        auto request                       = std::make_shared<Relocalize::Request>();
+        request->mode                      = mode_to_msg(mode);
+        request->initial_guess_world_base  = yaw_to_pose(x, y, yaw);
+
+        arm_timeout(session);
+
+        // executor 异步触发 callback。
+        auto pending_id = std::make_shared<std::int64_t>(-1);
+        auto s          = session;
+        auto result     = session->client->async_send_request(
+            std::move(request), [s, pending_id](RelocalizeClient::SharedFuture future) {
+                auto response = future.get();
+                if (!response) {
+                    RCLCPP_WARN(s->logger, "relocalize response is null");
+                    s->end(failed_status("response is null"), *pending_id);
+                    return;
+                }
+                if (!response->success) {
+                    RCLCPP_WARN(s->logger, "relocalize failed: %s", response->message.c_str());
+                    s->end(status_from_response(*response, false), *pending_id);
+                    return;
+                }
+                RCLCPP_INFO(
+                    s->logger, "relocalize success: score=%.4f, confidence=%.3f",
+                    response->fitness_score, response->confidence);
+                s->end(status_from_response(*response, true), *pending_id);
+            });
+        *pending_id = result.request_id;
+        session->track(result.request_id);
+        return true;
     }
 };
 
@@ -77,14 +210,12 @@ Localization::Localization(Config config)
 
 Localization::~Localization() noexcept = default;
 
-auto Localization::start_collecting(std::chrono::seconds seconds)
-    -> std::expected<void, std::string> {
-    return pimpl->start_collecting(seconds);
+auto Localization::relocalize(RelocalizeMode mode, double x, double y, double yaw) -> bool {
+    return pimpl->send(mode, x, y, yaw);
 }
 
-auto Localization::start_localizing(const Eigen::Isometry3d& initial_solution)
-    -> std::future<std::expected<Eigen::Isometry3d, std::string>> {
-    return pimpl->start_localizing(initial_solution);
+auto Localization::relocalize_status() const -> RelocalizeStatus {
+    return pimpl->session->snapshot();
 }
 
 } // namespace rmcs::navigation
diff --git a/src/cxx/util/localization/engine.hh b/src/cxx/util/localization/engine.hh
index ac111e5..992cf0d 100644
--- a/src/cxx/util/localization/engine.hh
+++ b/src/cxx/util/localization/engine.hh
@@ -1,37 +1,49 @@
 #pragma once
 #include "cxx/util/pimpl.hh"
 
-#include <Eigen/Geometry>
-#include <expected>
-#include <future>
+#include <cstdint>
 #include <rclcpp/node.hpp>
+#include <string>
 
 namespace rmcs::navigation {
 
+enum class RelocalizeState : std::uint8_t {
+    IDLE      = 0,
+    IN_FLIGHT = 1,
+    SUCCEEDED = 2,
+    FAILED    = 3,
+};
+
+enum class RelocalizeMode : std::uint8_t {
+    Initial = 0,
+    Local   = 1,
+    Wide    = 2,
+};
+
+struct RelocalizeStatus {
+    RelocalizeState state = RelocalizeState::IDLE;
+    bool success = false;
+    std::string message;
+    double fitness_score = 0.0, confidence = 0.0;
+    double estimated_x = 0.0, estimated_y = 0.0, estimated_z = 0.0;
+    double estimated_qx = 0.0, estimated_qy = 0.0, estimated_qz = 0.0, estimated_qw = 1.0;
+};
+
 class Localization {
     RMCS_PIMPL_DEFINITION(Localization)
 
 public:
     struct Config {
         rclcpp::Node& rclcpp;
-
-        std::string topic_registered;
-        std::string map_filename;
-
-        float ndt_resolution = 1.0;
-        double ndt_step_size = 0.1;
-        double ndt_result_epsilon = 0.01;
-        int ndt_max_iterations = 50;
+        std::string service_name = "/rmcs_relocation/relocalize";
+        double request_timeout_sec = 30.0;
     };
 
     explicit Localization(Config config);
 
-    // 开始收集配准好的点云
-    auto start_collecting(std::chrono::seconds seconds) -> std::expected<void, std::string>;
-
-    // 开始重定位
-    auto start_localizing(const Eigen::Isometry3d& initial_solution)
-        -> std::future<std::expected<Eigen::Isometry3d, std::string>>;
+    /// 唯一入口：mode + 三参 prior。返回 true=请求已挂起；false=被 in_flight / service 不可用拦截。
+    auto relocalize(RelocalizeMode mode, double x, double y, double yaw) -> bool;
+    auto relocalize_status() const -> RelocalizeStatus;
 };
 
 } // namespace rmcs::navigation
diff --git a/src/lua/action.lua b/src/lua/action.lua
index e9193b6..00e35e7 100644
--- a/src/lua/action.lua
+++ b/src/lua/action.lua
@@ -1,9 +1,17 @@
 local util = require("util.math")
 local api = require("api")
 local request = require("util.scheduler").request
+local blackboard = require("blackboard").singleton()
 
 local NaN = 0 / 0
 
+local RelocalizeState = {
+	IDLE = 0,
+	IN_FLIGHT = 1,
+	SUCCEEDED = 2,
+	FAILED = 3,
+}
+
 local action = {
 	target = {
 		x = NaN,
@@ -77,6 +85,70 @@ function action:update_chassis_vel(x, y)
 	api.update_chassis_vel(x, y)
 end
 
+--- 三模式共享：发起 → 轮询 → 终态。
+--- @return ok    boolean   是否被服务端 accept
+--- @return st    table?    末态 status（被 in-flight 拦截时为 nil）
+local function send_and_await(self, mode, fn, x, y, yaw)
+	if not fn(x, y, yaw) then
+		self:warn(string.format("reloc skip %s (in_flight)", mode))
+		return false, nil
+	end
+	while true do
+		local st = api.relocalize_status()
+		if st.state == RelocalizeState.SUCCEEDED then
+			self:info(string.format(
+				"reloc ok [%s] score=%.4f conf=%.3f", mode, st.fitness_score, st.confidence))
+			return true, st
+		end
+		if st.state ~= RelocalizeState.IN_FLIGHT then
+			self:warn(string.format(
+				"reloc fail [%s] score=%.4f conf=%.3f | %s",
+				mode, st.fitness_score, st.confidence, tostring(st.message)))
+			return false, st
+		end
+		request:sleep(0.1)
+	end
+end
+
+--- INITIAL 模式：x/y/yaw 是 GICP 起点（必须靠近真实位置）。开机/出生点重定位用。
+function action:relocalize_initial(x, y, yaw)
+	return send_and_await(self, "initial", api.relocalize_initial, x, y, yaw)
+end
+
+--- LOCAL 模式（SC-driven）：种子来自 ScanContext，不需要 GICP 起点。
+--- blackboard.user.{x,y,yaw} 仅作 validator 锚点（拦镜像错配）；
+function action:relocalize_local()
+	local user = blackboard.user
+	if util.check_nan(user.x, user.y, user.yaw) then
+		self:warn("reloc skip local (LIO/TF lost, no validator anchor)")
+		return false, nil
+	end
+	return send_and_await(self, "local_", api.relocalize_local, user.x, user.y, user.yaw)
+end
+
+--- WIDE 模式：blackboard.user 作 validator prior（NaN 时退化到原点 + 无 prior 验收）。
+function action:relocalize_wide()
+	local user = blackboard.user
+	local x, y, yaw = user.x, user.y, user.yaw
+	if util.check_nan(x, y, yaw) then x, y, yaw = 0.0, 0.0, 0.0 end
+	return send_and_await(self, "wide", api.relocalize_wide, x, y, yaw)
+end
+
+--- LOCAL 失败连续 2 次再降级 WIDE，防单帧抖动误触发全局重定位。
+--- 失败原因覆盖：SC 不可用 / 无匹配 / 错配被拦 / GICP 不收敛 / LIO 死。
+function action:try_relocalize_local_then_wide()
+	for attempt = 1, 2 do
+		if self:relocalize_local() then return true end
+		self:warn(string.format("local failed (attempt %d/2)", attempt))
+	end
+	self:warn("local failed twice, fallback wide")
+	return self:relocalize_wide()
+end
+
+function action:relocalize_status()
+	return api.relocalize_status()
+end
+
 function action:restart_navigation(config)
 	return api.restart_navigation(config)
 end
diff --git a/src/lua/api.lua b/src/lua/api.lua
index e7cef9e..be08d30 100644
--- a/src/lua/api.lua
+++ b/src/lua/api.lua
@@ -17,6 +17,10 @@ local util = require("util.native")
 --- @field update_gimbal_dominator fun(name: string)
 --- @field update_chassis_mode fun(mode: string)
 --- @field update_chassis_vel fun(x: number, y: number)
+--- @field relocalize_initial fun(x: number, y: number, yaw: number): boolean
+--- @field relocalize_local fun(x: number, y: number, yaw: number): boolean
+--- @field relocalize_wide fun(x: number, y: number, yaw: number): boolean
+--- @field relocalize_status fun(): { state: integer, success: boolean, message: string, fitness_score: number, confidence: number }
 ---
 local api = setmetatable({}, {
 	__index = function(_, name)