diff --git a/README.md b/README.md
index 0ad9161..57013d0 100644
--- a/README.md
+++ b/README.md
@@ -559,6 +559,32 @@ Callers must handle actual startup failures.
 Starts the managed Xray instance from the supplied JSON text. Use `stopXray`
 to stop that instance. `runXrayFromJson` is no longer a separate method.
 
+### probeManagedConnectivity
+
+Probes HTTPS through an explicitly named outbound of the existing managed core.
+Unlike `pingBatch`, it never starts another core, binds a listener, or changes the
+running configuration. Missing tags fail closed; there is no default or OS-direct
+fallback. Applications must select their own trusted health endpoints and verify
+the returned HTTP status and exact response body.
+
+```json
+{"apiVersion":3,"method":"probeManagedConnectivity","payload":{"outboundTag":"selected-proxy","url":"https://health.example.com/check","timeoutMilliseconds":7000}}
+```
+
+`url` must be absolute HTTPS without user information or a fragment. TLS uses
+system roots and hostname verification. Redirects are never followed. The timeout
+is 100–7000 ms (default 7000); response headers are limited to 4096 bytes and UTF-8
+body to 128 bytes. The method returns `success:true` for a completed probe with
+`data.status` equal to `response`, `failed`, or `unavailable`. A `response` includes
+`httpStatus` and `body`; failures include a fixed `reason` code, never raw network
+errors or request URLs. Invalid arguments use the normal `success:false` envelope.
+
+This checks the configured outbound transport, not OS packet capture, TUN traffic,
+or the system DNS path. The application owns stronger end-to-end verification.
+`stopXray` cancels active probes without waiting for their timeout; completion from
+a stopped/replaced managed instance is `unavailable`. Network I/O does not hold
+the core lifecycle mutex.
+
 ### metrics
 
 Refer to the following configuration:
diff --git a/invoke.go b/invoke.go
index 1f83241..c49d47e 100644
--- a/invoke.go
+++ b/invoke.go
@@ -57,6 +57,13 @@ func Invoke(requestJSON string) string {
 		return encodeInvokeResponse(&XrayVersionResponse{Version: xray.XrayVersion()}, nil)
 	case LibXrayMethodGetXrayState:
 		return encodeInvokeResponse(&GetXrayStateResponse{Running: xray.GetXrayState()}, nil)
+	case LibXrayMethodProbeManagedConnectivity:
+		request, err := decodePayload[ProbeManagedConnectivityRequest](request.Payload)
+		if err != nil {
+			return encodeInvokeResponse(nil, err)
+		}
+		result, err := xray.ProbeManagedConnectivity(request.OutboundTag, request.URL, request.TimeoutMilliseconds)
+		return encodeInvokeResponse(result, err)
 	default:
 		return encodeInvokeResponse(nil, errors.New("unknown method"))
 	}
diff --git a/invoke_model.go b/invoke_model.go
index 8914317..dde1ff9 100644
--- a/invoke_model.go
+++ b/invoke_model.go
@@ -21,6 +21,7 @@ const (
 	LibXrayMethodStopXray                    LibXrayMethod = "stopXray"
 	LibXrayMethodXrayVersion                 LibXrayMethod = "xrayVersion"
 	LibXrayMethodGetXrayState                LibXrayMethod = "getXrayState"
+	LibXrayMethodProbeManagedConnectivity    LibXrayMethod = "probeManagedConnectivity"
 )
 
 type LibXrayInvokeRequest struct {
@@ -116,3 +117,9 @@ type XrayVersionResponse struct {
 type GetXrayStateResponse struct {
 	Running bool `json:"running"`
 }
+
+type ProbeManagedConnectivityRequest struct {
+	OutboundTag         string `json:"outboundTag"`
+	URL                 string `json:"url"`
+	TimeoutMilliseconds int    `json:"timeoutMilliseconds,omitempty"`
+}
diff --git a/invoke_test.go b/invoke_test.go
index 7aee0dc..863bc9d 100644
--- a/invoke_test.go
+++ b/invoke_test.go
@@ -24,6 +24,24 @@ type testResponse struct {
 	Err     string          `json:"error,omitempty"`
 }
 
+func TestInvokeManagedProbeContract(t *testing.T) {
+	response := invokeForTest(t, LibXrayMethodProbeManagedConnectivity, ProbeManagedConnectivityRequest{OutboundTag: "route", URL: "https://example.com/", TimeoutMilliseconds: 7000})
+	if !response.Success {
+		t.Fatal(response.Err)
+	}
+	var data struct {
+		Status string `json:"status"`
+		Reason string `json:"reason"`
+	}
+	if err := json.Unmarshal(response.Data, &data); err != nil || data.Status != "unavailable" || data.Reason != "inactive" {
+		t.Fatalf("unexpected managed probe response: %s", response.Data)
+	}
+	response = invokeForTest(t, LibXrayMethodProbeManagedConnectivity, ProbeManagedConnectivityRequest{OutboundTag: "route", URL: "http://example.com/"})
+	if response.Success || response.Err == "" {
+		t.Fatal("invalid HTTPS target accepted")
+	}
+}
+
 func invokeForTest(t *testing.T, method LibXrayMethod, payload any) testResponse {
 	t.Helper()
 	rawPayload, err := json.Marshal(payload)
diff --git a/readme/README.zh_CN.md b/readme/README.zh_CN.md
index ac8b6e4..170ed0b 100644
--- a/readme/README.zh_CN.md
+++ b/readme/README.zh_CN.md
@@ -444,6 +444,27 @@ Geodata cron 不运行，但 assets 声明仍会检查本地文件。
 使用传入的 Xray JSON 文本启动由 libXray 管理的 Xray instance，并通过
 `stopXray` 停止。`runXrayFromJson` 不再作为独立 method 存在。
 
+### probeManagedConnectivity
+
+通过当前已启动核心的指定 outbound 检查 HTTPS，不创建第二个核心或监听端口，
+也不修改配置。outbound 不存在时返回不可用，绝不回退到默认或系统直连。
+应用负责选择可信的健康检查 URL，并验证 HTTP 状态及完整响应内容。
+
+```json
+{"apiVersion":3,"method":"probeManagedConnectivity","payload":{"outboundTag":"selected-proxy","url":"https://health.example.com/check","timeoutMilliseconds":7000}}
+```
+
+URL 必须是无用户信息和 fragment 的绝对 HTTPS URL。TLS 使用系统根证书并验证
+主机名，禁止重定向。超时限制为 100–7000 毫秒（默认 7000），响应头最大
+4096 字节，UTF-8 响应正文最大 128 字节。探测返回 `success:true` 和
+`data.status`：`response`、`failed` 或 `unavailable`。`response` 包含
+`httpStatus` 和 `body`；失败包含固定 `reason`，不暴露原始错误或 URL。
+非法参数使用标准 `success:false` 响应。
+
+该接口只验证指定 outbound 的传输，不证明系统流量捕获、TUN 或系统 DNS 路径。
+停止核心会立即取消探测；旧核心的结果为 `unavailable`。网络操作不持有核心
+生命周期锁，`stopXray` 无须等待探测超时。
+
 ### metrics
 
 App 直接通过 Xray metrics HTTP API 读取当前 instance 的流量计数；libXray 不采样或保存流量。
diff --git a/xray/managed_probe.go b/xray/managed_probe.go
new file mode 100644
index 0000000..957c194
--- /dev/null
+++ b/xray/managed_probe.go
@@ -0,0 +1,156 @@
+package xray
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	xrayNet "github.com/xtls/xray-core/common/net"
+	"github.com/xtls/xray-core/common/session"
+	"github.com/xtls/xray-core/core"
+	"github.com/xtls/xray-core/features/outbound"
+)
+
+const managedProbeMaxBody = 128
+
+// ManagedProbeResult confirms an HTTPS response through the requested existing
+// outbound only. The application must validate its endpoint's response body.
+// It does not prove capture of operating-system traffic or the TUN/DNS path.
+type ManagedProbeResult struct {
+	Status     string `json:"status"`
+	HTTPStatus int    `json:"httpStatus,omitempty"`
+	Body       string `json:"body,omitempty"`
+	Reason     string `json:"reason,omitempty"`
+}
+
+func ProbeManagedConnectivity(outboundTag, targetURL string, timeoutMilliseconds int) (ManagedProbeResult, error) {
+	return probeManagedConnectivity(outboundTag, targetURL, timeoutMilliseconds, nil)
+}
+
+// tlsConfig is private and used by local HTTPS tests to trust their fixture CA.
+// Public callers always use system certificate roots and hostname validation.
+func probeManagedConnectivity(outboundTag, targetURL string, timeoutMilliseconds int, tlsConfig *tls.Config) (ManagedProbeResult, error) {
+	target, err := url.Parse(targetURL)
+	if err != nil || len(targetURL) > 2048 || target.Scheme != "https" || target.Hostname() == "" || target.User != nil || target.Fragment != "" || target.Opaque != "" {
+		return ManagedProbeResult{}, errors.New("managed probe requires an absolute HTTPS URL without user info or fragment")
+	}
+	if strings.TrimSpace(outboundTag) != outboundTag || outboundTag == "" || len(outboundTag) > 128 {
+		return ManagedProbeResult{}, errors.New("managed probe requires an existing outbound tag")
+	}
+	if timeoutMilliseconds == 0 {
+		timeoutMilliseconds = 7000
+	}
+	if timeoutMilliseconds < 100 || timeoutMilliseconds > 7000 {
+		return ManagedProbeResult{}, errors.New("managed probe timeout must be between 100 and 7000 milliseconds")
+	}
+
+	coreServerMu.Lock()
+	server, lifetime := coreServer, coreProbeContext
+	if server == nil || lifetime == nil || lifetime.Err() != nil {
+		coreServerMu.Unlock()
+		return ManagedProbeResult{Status: "unavailable", Reason: "inactive"}, nil
+	}
+	manager, ok := server.GetFeature(outbound.ManagerType()).(outbound.Manager)
+	if !ok || manager.GetHandler(outboundTag) == nil {
+		coreServerMu.Unlock()
+		return ManagedProbeResult{Status: "unavailable", Reason: "missing_outbound"}, nil
+	}
+	coreServerMu.Unlock()
+
+	ctx, cancel := context.WithTimeout(lifetime, time.Duration(timeoutMilliseconds)*time.Millisecond)
+	defer cancel()
+	result := managedProbeHTTPS(ctx, server, outboundTag, targetURL, tlsConfig)
+	coreServerMu.Lock()
+	stale := server != coreServer || lifetime.Err() != nil
+	coreServerMu.Unlock()
+	if stale {
+		return ManagedProbeResult{Status: "unavailable", Reason: "stopped"}, nil
+	}
+	return result, nil
+}
+
+func managedProbeHTTPS(ctx context.Context, server *core.Instance, outboundTag, targetURL string, tlsConfig *tls.Config) ManagedProbeResult {
+	transport := &http.Transport{
+		Proxy:                  nil,
+		DisableKeepAlives:      true,
+		DisableCompression:     true,
+		TLSClientConfig:        tlsConfig,
+		MaxResponseHeaderBytes: 4096,
+		DialContext: func(dialCtx context.Context, network, address string) (net.Conn, error) {
+			if network != "tcp" && network != "tcp4" && network != "tcp6" {
+				return nil, errors.New("unsupported probe network")
+			}
+			destination, err := xrayNet.ParseDestination("tcp:" + address)
+			if err != nil {
+				return nil, err
+			}
+			if err := ctx.Err(); err != nil {
+				return nil, err
+			}
+			// http.Transport can detach a dial from request cancellation. Keep the
+			// managed lifetime/deadline on the core dispatch and explicitly close
+			// its virtual connection when this request expires or the core stops.
+			forced := session.SetForcedOutboundTagToContext(ctx, outboundTag)
+			connection, err := core.Dial(forced, server, destination)
+			if err != nil {
+				return nil, err
+			}
+			stop := context.AfterFunc(ctx, func() { _ = connection.Close() })
+			return &managedProbeConn{Conn: connection, stop: stop}, nil
+		},
+	}
+	defer transport.CloseIdleConnections()
+	client := &http.Client{Transport: transport, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, targetURL, nil)
+	if err != nil {
+		return ManagedProbeResult{Status: "failed", Reason: "request"}
+	}
+	request.Header.Set("Cache-Control", "no-cache")
+	response, err := client.Do(request)
+	if err != nil {
+		reason := "tls_or_transport"
+		if errors.Is(ctx.Err(), context.DeadlineExceeded) {
+			reason = "timeout"
+		}
+		return ManagedProbeResult{Status: "failed", Reason: reason}
+	}
+	defer response.Body.Close()
+	if response.StatusCode >= 300 && response.StatusCode <= 399 {
+		return ManagedProbeResult{Status: "failed", HTTPStatus: response.StatusCode, Reason: "redirect"}
+	}
+	body, err := io.ReadAll(io.LimitReader(response.Body, managedProbeMaxBody+1))
+	if err != nil {
+		reason := "read"
+		if errors.Is(ctx.Err(), context.DeadlineExceeded) {
+			reason = "timeout"
+		}
+		return ManagedProbeResult{Status: "failed", Reason: reason}
+	}
+	if len(body) > managedProbeMaxBody {
+		return ManagedProbeResult{Status: "failed", Reason: "response_too_large"}
+	}
+	if !utf8.Valid(body) {
+		return ManagedProbeResult{Status: "failed", Reason: "invalid_text"}
+	}
+	if ctx.Err() != nil {
+		return ManagedProbeResult{Status: "failed", Reason: "timeout"}
+	}
+	return ManagedProbeResult{Status: "response", HTTPStatus: response.StatusCode, Body: string(body)}
+}
+
+type managedProbeConn struct {
+	net.Conn
+	stop func() bool
+}
+
+func (connection *managedProbeConn) Close() error {
+	connection.stop()
+	return connection.Conn.Close()
+}
diff --git a/xray/managed_probe_test.go b/xray/managed_probe_test.go
new file mode 100644
index 0000000..d29669b
--- /dev/null
+++ b/xray/managed_probe_test.go
@@ -0,0 +1,147 @@
+package xray
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+const probeConfig = `{"log":{"loglevel":"none"},"outbounds":[{"protocol":"blackhole","tag":"default-block"},{"protocol":"freedom","tag":"fixture-route"}]}`
+
+func startProbeFixture(t *testing.T, handler http.HandlerFunc) (*httptest.Server, *tls.Config) {
+	t.Helper()
+	server := httptest.NewTLSServer(handler)
+	t.Cleanup(server.Close)
+	roots := x509.NewCertPool()
+	roots.AddCert(server.Certificate())
+	return server, &tls.Config{RootCAs: roots, MinVersion: tls.VersionTLS12}
+}
+
+func startManagedProbeCore(t *testing.T) {
+	t.Helper()
+	if err := RunXray(probeConfig); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = StopXray() })
+}
+
+func TestManagedProbeForcesExistingOutboundAndValidatesTLS(t *testing.T) {
+	server, trust := startProbeFixture(t, func(w http.ResponseWriter, r *http.Request) { _, _ = w.Write([]byte("fixture-ok")) })
+	startManagedProbeCore(t)
+	// The default route blocks; only explicit fixture-route can reach TLS.
+	result, err := probeManagedConnectivity("fixture-route", server.URL, 1000, trust)
+	if err != nil || result.Status != "response" || result.HTTPStatus != 200 || result.Body != "fixture-ok" {
+		t.Fatalf("forced route: %+v %v", result, err)
+	}
+	result, err = ProbeManagedConnectivity("fixture-route", server.URL, 1000)
+	if err != nil || result.Status != "failed" || result.Reason != "tls_or_transport" {
+		t.Fatalf("untrusted TLS accepted: %+v %v", result, err)
+	}
+	// Explicitly absent routes may never fall back to the default outbound.
+	result, err = probeManagedConnectivity("missing", server.URL, 1000, trust)
+	if err != nil || result.Status != "unavailable" || result.Reason != "missing_outbound" {
+		t.Fatalf("missing route: %+v %v", result, err)
+	}
+}
+
+func TestManagedProbeRejectsRedirectAndOversizedBody(t *testing.T) {
+	var redirectFollowed atomic.Bool
+	server, trust := startProbeFixture(t, func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/redirect":
+			http.Redirect(w, r, "/secret", http.StatusFound)
+		case "/secret":
+			redirectFollowed.Store(true)
+			_, _ = w.Write([]byte("bad"))
+		default:
+			_, _ = w.Write([]byte(strings.Repeat("a", 129)))
+		}
+	})
+	startManagedProbeCore(t)
+	result, err := probeManagedConnectivity("fixture-route", server.URL+"/redirect", 1000, trust)
+	if err != nil || result.Reason != "redirect" || redirectFollowed.Load() {
+		t.Fatalf("redirect followed: %+v %v", result, err)
+	}
+	result, err = probeManagedConnectivity("fixture-route", server.URL, 1000, trust)
+	if err != nil || result.Reason != "response_too_large" || result.Body != "" {
+		t.Fatalf("unbounded body: %+v %v", result, err)
+	}
+}
+
+func TestManagedProbeTimeoutClosesVirtualConnection(t *testing.T) {
+	entered, closed := make(chan struct{}), make(chan struct{})
+	server, trust := startProbeFixture(t, func(w http.ResponseWriter, r *http.Request) { close(entered); <-r.Context().Done(); close(closed) })
+	startManagedProbeCore(t)
+	started := time.Now()
+	result, err := probeManagedConnectivity("fixture-route", server.URL, 200, trust)
+	if err != nil || result.Status != "failed" || result.Reason != "timeout" || time.Since(started) > time.Second {
+		t.Fatalf("unbounded timeout: %+v %v", result, err)
+	}
+	select {
+	case <-entered:
+	default:
+		t.Fatal("fixture not reached")
+	}
+	select {
+	case <-closed:
+	case <-time.After(time.Second):
+		t.Fatal("timed-out core connection not closed")
+	}
+}
+
+func TestManagedProbeStopCancelsWithoutWaitingForDeadline(t *testing.T) {
+	entered := make(chan struct{})
+	server, trust := startProbeFixture(t, func(w http.ResponseWriter, r *http.Request) { close(entered); <-r.Context().Done() })
+	startManagedProbeCore(t)
+	resultChannel := make(chan ManagedProbeResult, 1)
+	go func() {
+		result, _ := probeManagedConnectivity("fixture-route", server.URL, 7000, trust)
+		resultChannel <- result
+	}()
+	select {
+	case <-entered:
+	case <-time.After(time.Second):
+		t.Fatal("fixture not reached")
+	}
+	started := time.Now()
+	if err := StopXray(); err != nil {
+		t.Fatal(err)
+	}
+	if time.Since(started) > time.Second {
+		t.Fatal("stop waited for probe timeout")
+	}
+	// A new generation must never adopt completion from the cancelled one.
+	if err := RunXray(probeConfig); err != nil {
+		t.Fatal(err)
+	}
+	select {
+	case result := <-resultChannel:
+		if result.Status != "unavailable" || result.Reason != "stopped" {
+			t.Fatalf("stale success: %+v", result)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("probe not cancelled")
+	}
+}
+
+func TestManagedProbeRequestValidationAndInactive(t *testing.T) {
+	for _, target := range []string{"http://example.com/", "https://user:secret@example.com/", "https://example.com/#x", "/relative"} {
+		if _, err := ProbeManagedConnectivity("route", target, 7000); err == nil {
+			t.Fatalf("accepted %q", target)
+		}
+	}
+	for _, timeout := range []int{-1, 99, 7001} {
+		if _, err := ProbeManagedConnectivity("route", "https://example.com", timeout); err == nil {
+			t.Fatal("bad timeout accepted")
+		}
+	}
+	result, err := ProbeManagedConnectivity("route", "https://example.com", 0)
+	if err != nil || result.Status != "unavailable" || result.Reason != "inactive" {
+		t.Fatalf("inactive: %+v %v", result, err)
+	}
+}
diff --git a/xray/xray.go b/xray/xray.go
index f6fe078..3a1164a 100644
--- a/xray/xray.go
+++ b/xray/xray.go
@@ -1,6 +1,7 @@
 package xray
 
 import (
+	"context"
 	"errors"
 	"runtime/debug"
 	"strings"
@@ -12,8 +13,10 @@ import (
 )
 
 var (
-	coreServerMu sync.Mutex
-	coreServer   *core.Instance
+	coreServerMu     sync.Mutex
+	coreServer       *core.Instance
+	coreProbeContext context.Context
+	coreProbeCancel  context.CancelFunc
 )
 
 var ErrAlreadyRunning = errors.New("xray is already running")
@@ -50,6 +53,7 @@ func RunXray(xrayJSON string) error {
 		return err
 	}
 	coreServer = server
+	coreProbeContext, coreProbeCancel = context.WithCancel(context.Background())
 
 	debug.FreeOSMemory()
 	return nil
@@ -67,8 +71,12 @@ func StopXray() error {
 	coreServerMu.Lock()
 	defer coreServerMu.Unlock()
 	if coreServer != nil {
+		if coreProbeCancel != nil {
+			coreProbeCancel()
+		}
 		err := coreServer.Close()
 		coreServer = nil
+		coreProbeContext, coreProbeCancel = nil, nil
 		if err != nil {
 			return err
 		}
