--- a/xray/xray.go
+++ b/xray/xray.go
@@ -9,7 +9,10 @@
 
 	"github.com/xtls/libxray/memory"
 	"github.com/xtls/xray-core/core"
+	"github.com/xtls/xray-core/features/inbound"
 	_ "github.com/xtls/xray-core/main/distro/all"
+	"github.com/xtls/xray-core/proxy"
+	"github.com/xtls/xray-core/proxy/tun"
 )
 
 var (
@@ -66,6 +69,42 @@
 	return coreServer != nil && coreServer.IsRunning()
 }
 
+// ManagedXrayState adds local TUN lifecycle evidence without claiming traffic
+// forwarding. Missing readers and inactive instances are not reader failures.
+type ManagedXrayState struct {
+	Running    bool                       `json:"running"`
+	TUNReaders map[string]tun.ReaderState `json:"tunReaders,omitempty"`
+}
+
+func GetManagedXrayState() ManagedXrayState {
+	coreServerMu.Lock()
+	defer coreServerMu.Unlock()
+	result := ManagedXrayState{Running: coreServer != nil && coreServer.IsRunning()}
+	if !result.Running {
+		return result
+	}
+	if manager, ok := coreServer.GetFeature(inbound.ManagerType()).(inbound.Manager); ok {
+		result.TUNReaders = managedTUNReaders(manager.ListHandlers(context.Background()))
+	}
+	return result
+}
+
+func managedTUNReaders(handlers []inbound.Handler) map[string]tun.ReaderState {
+	result := make(map[string]tun.ReaderState)
+	for _, handler := range handlers {
+		unwrapped, ok := handler.(interface{ GetInbound() proxy.Inbound })
+		if !ok {
+			continue
+		}
+		reader, ok := unwrapped.GetInbound().(interface{ TUNReaderState() tun.ReaderState })
+		if !ok {
+			continue
+		}
+		result[handler.Tag()] = reader.TUNReaderState()
+	}
+	return result
+}
+
 // Stop Xray instance.
 func StopXray() error {
 	coreServerMu.Lock()
--- /dev/null
+++ b/xray/tun_state_test.go
@@ -0,0 +1,76 @@
+package xray
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/xtls/xray-core/features/inbound"
+	"github.com/xtls/xray-core/proxy"
+	"github.com/xtls/xray-core/proxy/tun"
+)
+
+type stateTestProxy struct {
+	proxy.Inbound
+	state tun.ReaderState
+}
+
+func (p *stateTestProxy) TUNReaderState() tun.ReaderState { return p.state }
+
+type stateTestHandler struct {
+	inbound.Handler
+	tag string
+	in  proxy.Inbound
+}
+
+func (h *stateTestHandler) Tag() string               { return h.tag }
+func (*stateTestHandler) Start() error                { return nil }
+func (*stateTestHandler) Close() error                { return nil }
+func (h *stateTestHandler) GetInbound() proxy.Inbound { return h.in }
+func TestManagedTUNStateUsesCurrentManagedInstance(t *testing.T) {
+	if err := RunXray(probeConfig); err != nil {
+		t.Fatal(err)
+	}
+	defer StopXray()
+	manager := coreServer.GetFeature(inbound.ManagerType()).(inbound.Manager)
+	handler := &stateTestHandler{tag: "fixture-tun", in: &stateTestProxy{state: tun.ReaderState{State: "failed", ErrorKind: "errno", ErrorCode: 5}}}
+	if err := manager.AddHandler(context.Background(), handler); err != nil {
+		t.Fatal(err)
+	}
+	state := GetManagedXrayState()
+	if !state.Running || state.TUNReaders["fixture-tun"].State != "failed" {
+		t.Fatalf("missing native state %+v", state)
+	}
+	encoded, err := json.Marshal(state)
+	if err != nil || !strings.Contains(string(encoded), `"errorCode":5`) {
+		t.Fatal("wrong JSON shape")
+	}
+	if err = StopXray(); err != nil {
+		t.Fatal(err)
+	}
+	state = GetManagedXrayState()
+	if state.Running || len(state.TUNReaders) != 0 {
+		t.Fatal("stopped core retained reader failure")
+	}
+	if err = RunXray(probeConfig); err != nil {
+		t.Fatal(err)
+	}
+	state = GetManagedXrayState()
+	if !state.Running || len(state.TUNReaders) != 0 {
+		t.Fatal("replacement core inherited old reader failure")
+	}
+}
+func TestManagedTUNStateDoesNotInventFailureForMissingSupport(t *testing.T) {
+	if got := managedTUNReaders([]inbound.Handler{&stateTestHandler{tag: "unsupported", in: nil}}); len(got) != 0 {
+		t.Fatal("unsupported reader reported")
+	}
+	if err := RunXray(probeConfig); err != nil {
+		t.Fatal(err)
+	}
+	defer StopXray()
+	state := GetManagedXrayState()
+	if !state.Running || len(state.TUNReaders) != 0 {
+		t.Fatal("ordinary core reported TUN failure")
+	}
+}
--- a/invoke.go
+++ b/invoke.go
@@ -56,7 +56,7 @@
 	case LibXrayMethodXrayVersion:
 		return encodeInvokeResponse(&XrayVersionResponse{Version: xray.XrayVersion()}, nil)
 	case LibXrayMethodGetXrayState:
-		return encodeInvokeResponse(&GetXrayStateResponse{Running: xray.GetXrayState()}, nil)
+		return encodeInvokeResponse(xray.GetManagedXrayState(), nil)
 	case LibXrayMethodProbeManagedConnectivity:
 		request, err := decodePayload[ProbeManagedConnectivityRequest](request.Payload)
 		if err != nil {
--- a/invoke_model.go
+++ b/invoke_model.go
@@ -3,6 +3,7 @@
 
 import (
 	"encoding/json"
+	"github.com/xtls/libxray/xray"
 )
 
 type LibXrayMethod string
@@ -114,9 +115,7 @@
 	Version string `json:"version,omitempty"`
 }
 
-type GetXrayStateResponse struct {
-	Running bool `json:"running"`
-}
+type GetXrayStateResponse = xray.ManagedXrayState
 
 type ProbeManagedConnectivityRequest struct {
 	OutboundTag         string `json:"outboundTag"`
--- a/README.md
+++ b/README.md
@@ -638,3 +638,17 @@
 # License
 
 This repository is based on the MIT License.
+
+## getXrayState
+
+`getXrayState` with an empty payload retains `data.running` and may include
+`data.tunReaders`, a map keyed by the current managed TUN inbound tag. Each entry
+contains `state` (`running`, `failed`, `stopped`, or `unavailable`). A failed read
+also includes a sanitized `errorKind` (`errno`, `eof`, or `other`) and an optional
+numeric `errorCode` for errno. No packet contents, addresses, or raw errors are
+returned. Missing entries, older library responses, inactive cores and unavailable
+readers are not failure evidence. `running` is not proof of end-to-end forwarding.
+Read snapshots are synchronized with core start/stop and native reader lifecycle.
+Consumers must reject results from obsolete app/core generations before recovery;
+intentional shutdown and a superseded reader cannot report a new reader failure.
+The API remains version 3; no new method or cryptographic behavior is introduced.
--- a/readme/README.zh_CN.md
+++ b/readme/README.zh_CN.md
@@ -518,3 +518,14 @@
 # License
 
 本仓库基于 MIT License 。
+
+## getXrayState
+
+`getXrayState` 接受空 payload，保留 `data.running`，并可返回
+`data.tunReaders`（以当前受管理 TUN inbound tag 为键）。每项包含 `state`：
+`running`、`failed`、`stopped` 或 `unavailable`。读取失败只返回经过清理的
+`errorKind`（`errno`、`eof` 或 `other`）以及可选的数字 `errorCode`。
+不返回数据包、地址或原始错误消息。缺失字段、旧版本响应、未运行的核心和
+不可用状态都不是故障证据。`running` 不表示端到端转发成功。状态读取与核心
+生命周期及读取器同步；消费者恢复前必须丢弃过期 generation 的结果。主动关闭
+和已替换的读取器不会报告新读取器故障。API 版本仍为 3，无新增 method 或加密变更。
--- /dev/null
+++ b/tun_state_darwin_test.go
@@ -0,0 +1,62 @@
+//go:build darwin
+
+package libXray
+
+import (
+	"fmt"
+	"os"
+	"testing"
+	"time"
+)
+
+// A pipe supplies the same borrowed-descriptor API used by iOS without creating
+// a system VPN or making any network request. Closing its writer gives the real
+// DarwinTun read path an EOF, not an invented wrapper snapshot.
+func TestInvokeRealDarwinTUNReaderFailureAndReplacement(t *testing.T) {
+	t.Setenv("xray.tun.fd", "")
+	t.Cleanup(func() { _ = invokeForTest(t, LibXrayMethodStopXray, nil) })
+	for attempt := 0; attempt < 2; attempt++ {
+		read, write, err := os.Pipe()
+		if err != nil {
+			t.Fatal(err)
+		}
+		config := fmt.Sprintf(`{"env":{"xray.tun.fd":"%d"},"log":{"loglevel":"none"},"inbounds":[{"tag":"tivra-tun","protocol":"tun","port":0,"settings":{"name":"utun","mtu":1280}}],"outbounds":[{"protocol":"blackhole"}]}`, read.Fd())
+		response := invokeForTest(t, LibXrayMethodRunXray, RunXrayRequest{XrayJson: config})
+		if !response.Success {
+			read.Close()
+			write.Close()
+			t.Fatalf("start: %s", response.Err)
+		}
+		state := decodeDataObject[GetXrayStateResponse](t, invokeForTest(t, LibXrayMethodGetXrayState, nil))
+		if !state.Running || state.TUNReaders["tivra-tun"].State != "running" {
+			t.Fatalf("replacement did not start clean: %+v", state)
+		}
+		write.Close()
+		deadline := time.Now().Add(2 * time.Second)
+		for {
+			state = decodeDataObject[GetXrayStateResponse](t, invokeForTest(t, LibXrayMethodGetXrayState, nil))
+			if state.TUNReaders["tivra-tun"].State == "failed" {
+				break
+			}
+			if time.Now().After(deadline) {
+				t.Fatalf("real TUN EOF never surfaced: %+v", state)
+			}
+			time.Sleep(time.Millisecond)
+		}
+		if !state.Running || state.TUNReaders["tivra-tun"].ErrorKind != "eof" {
+			t.Fatalf("wrong local fault state %+v", state)
+		}
+		response = invokeForTest(t, LibXrayMethodStopXray, nil)
+		if !response.Success {
+			t.Fatal(response.Err)
+		}
+		state = decodeDataObject[GetXrayStateResponse](t, invokeForTest(t, LibXrayMethodGetXrayState, nil))
+		if state.Running || len(state.TUNReaders) > 0 {
+			t.Fatal("stopped snapshot retained failure")
+		}
+		if _, err = read.Stat(); err != nil {
+			t.Fatal("core closed caller-owned input descriptor")
+		}
+		read.Close()
+	}
+}
